Context navigation

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

Last change on this file since 13033 was 13031, checked in by Henrik Bettermann, 10 years ago
Implement session-specific course registration deadline and late registration payment.
Property svn:keywords set to `Id`
File size: 128.3 KB

Line
1	## $Id: browser.py 13031 2015-06-04 14:21:23Z 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(
759	self.context)
760	if cdm:
761	self.flash(cdm)
762	self.redirect(self.url(self.context,'view_clearance'))
763	return
764	if self.context.state == REQUESTED:
765	IWorkflowInfo(self.context).fireTransition('clear')
766	self.flash(_('Student has been cleared.'))
767	else:
768	self.flash(_('Student is in wrong state.'), type="warning")
769	self.redirect(self.url(self.context,'view_clearance'))
770	return
771
772	def render(self):
773	return
774
775	class StudentRejectClearancePage(KofaEditFormPage):
776	""" Reject clearance by clearance officers.
777	"""
778	grok.context(IStudent)
779	grok.name('reject_clearance')
780	label = _('Reject clearance')
781	grok.require('waeup.clearStudent')
782	form_fields = grok.AutoFields(
783	IUGStudentClearance).select('officer_comment')
784
785	def update(self):
786	cdm = getUtility(IStudentsUtils).clearance_disabled_message(
787	self.context)
788	if cdm:
789	self.flash(cdm, type="warning")
790	self.redirect(self.url(self.context,'view_clearance'))
791	return
792	return super(StudentRejectClearancePage, self).update()
793
794	@action(_('Save comment and reject clearance now'), style='primary')
795	def reject(self, **data):
796	if self.context.state == CLEARED:
797	IWorkflowInfo(self.context).fireTransition('reset4')
798	message = _('Clearance has been annulled.')
799	self.flash(message, type="warning")
800	elif self.context.state == REQUESTED:
801	IWorkflowInfo(self.context).fireTransition('reset3')
802	message = _('Clearance request has been rejected.')
803	self.flash(message, type="warning")
804	else:
805	self.flash(_('Student is in wrong state.'), type="warning")
806	self.redirect(self.url(self.context,'view_clearance'))
807	return
808	self.applyData(self.context, **data)
809	comment = data['officer_comment']
810	if comment:
811	self.context.writeLogMessage(
812	self, 'comment: %s' % comment.replace('\n', '<br>'))
813	args = {'subject':message, 'body':comment}
814	else:
815	args = {'subject':message,}
816	self.redirect(self.url(self.context) +
817	'/contactstudent?%s' % urlencode(args))
818	return
819
820
821	class StudentPersonalDisplayFormPage(KofaDisplayFormPage):
822	""" Page to display student personal data
823	"""
824	grok.context(IStudent)
825	grok.name('view_personal')
826	grok.require('waeup.viewStudent')
827	form_fields = grok.AutoFields(IStudentPersonal)
828	form_fields['perm_address'].custom_widget = BytesDisplayWidget
829	form_fields[
830	'personal_updated'].custom_widget = FriendlyDatetimeDisplayWidget('le')
831	pnav = 4
832
833	@property
834	def label(self):
835	return _('${a}: Personal Data',
836	mapping = {'a':self.context.display_fullname})
837
838	class StudentPersonalManageFormPage(KofaEditFormPage):
839	""" Page to manage personal data
840	"""
841	grok.context(IStudent)
842	grok.name('manage_personal')
843	grok.require('waeup.manageStudent')
844	form_fields = grok.AutoFields(IStudentPersonal)
845	form_fields['personal_updated'].for_display = True
846	form_fields[
847	'personal_updated'].custom_widget = FriendlyDatetimeDisplayWidget('le')
848	label = _('Manage personal data')
849	pnav = 4
850
851	@action(_('Save'), style='primary')
852	def save(self, **data):
853	msave(self, **data)
854	return
855
856	class StudentPersonalEditFormPage(KofaEditFormPage):
857	""" Page to edit personal data
858	"""
859	grok.context(IStudent)
860	grok.name('edit_personal')
861	grok.require('waeup.handleStudent')
862	form_fields = grok.AutoFields(IStudentPersonalEdit).omit('personal_updated')
863	label = _('Edit personal data')
864	pnav = 4
865
866	@action(_('Save/Confirm'), style='primary')
867	def save(self, **data):
868	msave(self, **data)
869	self.context.personal_updated = datetime.utcnow()
870	return
871
872	class StudyCourseDisplayFormPage(KofaDisplayFormPage):
873	""" Page to display the student study course data
874	"""
875	grok.context(IStudentStudyCourse)
876	grok.name('index')
877	grok.require('waeup.viewStudent')
878	grok.template('studycoursepage')
879	pnav = 4
880
881	@property
882	def form_fields(self):
883	if self.context.is_postgrad:
884	form_fields = grok.AutoFields(IStudentStudyCourse).omit(
885	'previous_verdict')
886	else:
887	form_fields = grok.AutoFields(IStudentStudyCourse)
888	return form_fields
889
890	@property
891	def label(self):
892	if self.context.is_current:
893	return _('${a}: Study Course',
894	mapping = {'a':self.context.__parent__.display_fullname})
895	else:
896	return _('${a}: Previous Study Course',
897	mapping = {'a':self.context.__parent__.display_fullname})
898
899	@property
900	def current_mode(self):
901	if self.context.certificate is not None:
902	studymodes_dict = getUtility(IKofaUtils).STUDY_MODES_DICT
903	return studymodes_dict[self.context.certificate.study_mode]
904	return
905
906	@property
907	def department(self):
908	if self.context.certificate is not None:
909	return self.context.certificate.__parent__.__parent__
910	return
911
912	@property
913	def faculty(self):
914	if self.context.certificate is not None:
915	return self.context.certificate.__parent__.__parent__.__parent__
916	return
917
918	@property
919	def prev_studycourses(self):
920	if self.context.is_current:
921	if self.context.__parent__.get('studycourse_2', None) is not None:
922	return (
923	{'href':self.url(self.context.student) + '/studycourse_1',
924	'title':_('First Study Course, ')},
925	{'href':self.url(self.context.student) + '/studycourse_2',
926	'title':_('Second Study Course')}
927	)
928	if self.context.__parent__.get('studycourse_1', None) is not None:
929	return (
930	{'href':self.url(self.context.student) + '/studycourse_1',
931	'title':_('First Study Course')},
932	)
933	return
934
935	class StudyCourseManageFormPage(KofaEditFormPage):
936	""" Page to edit the student study course data
937	"""
938	grok.context(IStudentStudyCourse)
939	grok.name('manage')
940	grok.require('waeup.manageStudent')
941	grok.template('studycoursemanagepage')
942	label = _('Manage study course')
943	pnav = 4
944	taboneactions = [_('Save'),_('Cancel')]
945	tabtwoactions = [_('Remove selected levels'),_('Cancel')]
946	tabthreeactions = [_('Add study level')]
947
948	@property
949	def form_fields(self):
950	if self.context.is_postgrad:
951	form_fields = grok.AutoFields(IStudentStudyCourse).omit(
952	'previous_verdict')
953	else:
954	form_fields = grok.AutoFields(IStudentStudyCourse)
955	return form_fields
956
957	def update(self):
958	if not self.context.is_current:
959	emit_lock_message(self)
960	return
961	super(StudyCourseManageFormPage, self).update()
962	return
963
964	@action(_('Save'), style='primary')
965	def save(self, **data):
966	try:
967	msave(self, **data)
968	except ConstraintNotSatisfied:
969	# The selected level might not exist in certificate
970	self.flash(_('Current level not available for certificate.'),
971	type="warning")
972	return
973	notify(grok.ObjectModifiedEvent(self.context.__parent__))
974	return
975
976	@property
977	def level_dicts(self):
978	studylevelsource = StudyLevelSource().factory
979	for code in studylevelsource.getValues(self.context):
980	title = studylevelsource.getTitle(self.context, code)
981	yield(dict(code=code, title=title))
982
983	@property
984	def session_dicts(self):
985	yield(dict(code='', title='--'))
986	for item in academic_sessions():
987	code = item[1]
988	title = item[0]
989	yield(dict(code=code, title=title))
990
991	@action(_('Add study level'), style='primary')
992	def addStudyLevel(self, **data):
993	level_code = self.request.form.get('addlevel', None)
994	level_session = self.request.form.get('level_session', None)
995	if not level_session:
996	self.flash(_('You must select a session for the level.'),
997	type="warning")
998	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
999	return
1000	studylevel = createObject(u'waeup.StudentStudyLevel')
1001	studylevel.level = int(level_code)
1002	studylevel.level_session = int(level_session)
1003	try:
1004	self.context.addStudentStudyLevel(
1005	self.context.certificate,studylevel)
1006	self.flash(_('Study level has been added.'))
1007	except KeyError:
1008	self.flash(_('This level exists.'), type="warning")
1009	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1010	return
1011
1012	@jsaction(_('Remove selected levels'))
1013	def delStudyLevels(self, **data):
1014	form = self.request.form
1015	if 'val_id' in form:
1016	child_id = form['val_id']
1017	else:
1018	self.flash(_('No study level selected.'), type="warning")
1019	self.redirect(self.url(self.context, '@@manage')+'#tab2')
1020	return
1021	if not isinstance(child_id, list):
1022	child_id = [child_id]
1023	deleted = []
1024	for id in child_id:
1025	del self.context[id]
1026	deleted.append(id)
1027	if len(deleted):
1028	self.flash(_('Successfully removed: ${a}',
1029	mapping = {'a':', '.join(deleted)}))
1030	self.context.writeLogMessage(
1031	self,'removed: %s' % ', '.join(deleted))
1032	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1033	return
1034
1035	class StudentTranscriptRequestPage(KofaPage):
1036	""" Page to transcript by student
1037	"""
1038	grok.context(IStudent)
1039	grok.name('request_transcript')
1040	grok.require('waeup.handleStudent')
1041	grok.template('transcriptrequest')
1042	label = _('Request transcript')
1043	ac_prefix = 'TSC'
1044	notice = ''
1045	pnav = 4
1046	buttonname = _('Submit')
1047	with_ac = True
1048
1049	def update(self, SUBMIT=None):
1050	super(StudentTranscriptRequestPage, self).update()
1051	if not self.context.state == GRADUATED:
1052	self.flash(_("Wrong state"), type="danger")
1053	self.redirect(self.url(self.context))
1054	return
1055	if self.with_ac:
1056	self.ac_series = self.request.form.get('ac_series', None)
1057	self.ac_number = self.request.form.get('ac_number', None)
1058	if self.context.transcript_comment is not None:
1059	self.correspondence = self.context.transcript_comment.replace(
1060	'\n', '<br>')
1061	else:
1062	self.correspondence = ''
1063	if SUBMIT is None:
1064	return
1065	if self.with_ac:
1066	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
1067	code = get_access_code(pin)
1068	if not code:
1069	self.flash(_('Activation code is invalid.'), type="warning")
1070	return
1071	if code.state == USED:
1072	self.flash(_('Activation code has already been used.'),
1073	type="warning")
1074	return
1075	# Mark pin as used (this also fires a pin related transition)
1076	# and fire transition start_clearance
1077	comment = _(u"invalidated")
1078	# Here we know that the ac is in state initialized so we do not
1079	# expect an exception, but the owner might be different
1080	if not invalidate_accesscode(pin, comment, self.context.student_id):
1081	self.flash(_('You are not the owner of this access code.'),
1082	type="warning")
1083	return
1084	self.context.clr_code = pin
1085	IWorkflowInfo(self.context).fireTransition('request_transcript')
1086	comment = self.request.form.get('comment', '').replace('\r', '')
1087	address = self.request.form.get('address', '').replace('\r', '')
1088	tz = getattr(queryUtility(IKofaUtils), 'tzinfo', pytz.utc)
1089	today = now(tz).strftime('%d/%m/%Y %H:%M:%S %Z')
1090	old_transcript_comment = self.context.transcript_comment
1091	if old_transcript_comment == None:
1092	old_transcript_comment = ''
1093	self.context.transcript_comment = '''On %s %s wrote:
1094
1095	%s
1096
1097	Dispatch Address:
1098	%s
1099
1100	%s''' % (today, self.request.principal.id, comment, address,
1101	old_transcript_comment)
1102	self.context.writeLogMessage(
1103	self, 'comment: %s' % comment.replace('\n', '<br>'))
1104	self.flash(_('Transcript processing has been started.'))
1105	self.redirect(self.url(self.context))
1106	return
1107
1108	class StudentTranscriptRequestProcessFormPage(KofaEditFormPage):
1109	""" Page to process transcript requests
1110	"""
1111	grok.context(IStudent)
1112	grok.name('process_transcript_request')
1113	grok.require('waeup.viewTranscript')
1114	grok.template('transcriptprocess')
1115	form_fields = grok.AutoFields(IStudentTranscript)
1116	label = _('Process transcript request')
1117	buttonname = _('Save comment and mark as processed')
1118	pnav = 4
1119
1120	def update(self, SUBMIT=None):
1121	super(StudentTranscriptRequestProcessFormPage, self).update()
1122	if self.context.state != TRANSCRIPT:
1123	self.flash(_('Student is in wrong state.'), type="warning")
1124	self.redirect(self.url(self.context))
1125	return
1126	if self.context.transcript_comment is not None:
1127	self.correspondence = self.context.transcript_comment.replace(
1128	'\n', '<br>')
1129	else:
1130	self.correspondence = ''
1131	if SUBMIT is None:
1132	return
1133	IWorkflowInfo(self.context).fireTransition('process_transcript')
1134	self.flash(_('Transcript request processed.'))
1135	comment = self.request.form.get('comment', '').replace('\r', '')
1136	tz = getattr(queryUtility(IKofaUtils), 'tzinfo', pytz.utc)
1137	today = now(tz).strftime('%d/%m/%Y %H:%M:%S %Z')
1138	old_transcript_comment = self.context.transcript_comment
1139	if old_transcript_comment == None:
1140	old_transcript_comment = ''
1141	self.context.transcript_comment = '''On %s %s wrote:
1142
1143	%s
1144
1145	%s''' % (today, self.request.principal.id, comment,
1146	old_transcript_comment)
1147	self.context.writeLogMessage(
1148	self, 'comment: %s' % comment.replace('\n', '<br>'))
1149	subject = _('Transcript processed')
1150	args = {'subject':subject, 'body':comment}
1151	self.redirect(self.url(self.context) +
1152	'/contactstudent?%s' % urlencode(args))
1153	return
1154
1155	class StudentTranscriptRequestManageFormPage(KofaEditFormPage):
1156	""" Page to edit personal data by student
1157	"""
1158	grok.context(IStudent)
1159	grok.name('manage_transcript_request')
1160	grok.require('waeup.manageStudent')
1161	form_fields = grok.AutoFields(IStudentTranscript)
1162	label = _('Manage transcript request')
1163	pnav = 4
1164
1165	@action(_('Save'), style='primary')
1166	def save(self, **data):
1167	msave(self, **data)
1168	return
1169
1170	class StudyCourseTranscriptPage(KofaDisplayFormPage):
1171	""" Page to display the student's transcript.
1172	"""
1173	grok.context(IStudentStudyCourseTranscript)
1174	grok.name('transcript')
1175	grok.require('waeup.viewTranscript')
1176	grok.template('transcript')
1177	pnav = 4
1178
1179	def update(self):
1180	if not self.context.student.transcript_enabled:
1181	self.flash(_('You are not allowed to view the transcript.'),
1182	type="warning")
1183	self.redirect(self.url(self.context))
1184	return
1185	super(StudyCourseTranscriptPage, self).update()
1186	self.semester_dict = getUtility(IKofaUtils).SEMESTER_DICT
1187	self.level_dict = level_dict(self.context)
1188	self.session_dict = dict(
1189	[(item[1], item[0]) for item in academic_sessions()])
1190	self.studymode_dict = getUtility(IKofaUtils).STUDY_MODES_DICT
1191	return
1192
1193	@property
1194	def label(self):
1195	# Here we know that the cookie has been set
1196	lang = self.request.cookies.get('kofa.language')
1197	return _('${a}: Transcript Data', mapping = {
1198	'a':self.context.student.display_fullname})
1199
1200	class ExportPDFTranscriptPage(UtilityView, grok.View):
1201	"""Deliver a PDF slip of the context.
1202	"""
1203	grok.context(IStudentStudyCourse)
1204	grok.name('transcript.pdf')
1205	grok.require('waeup.viewTranscript')
1206	form_fields = grok.AutoFields(IStudentStudyCourseTranscript)
1207	prefix = 'form'
1208	omit_fields = (
1209	'department', 'faculty', 'current_mode', 'entry_session', 'certificate',
1210	'password', 'suspended', 'phone', 'email',
1211	'adm_code', 'suspended_comment', 'current_level')
1212
1213	def update(self):
1214	if not self.context.student.transcript_enabled:
1215	self.flash(_('You are not allowed to download the transcript.'),
1216	type="warning")
1217	self.redirect(self.url(self.context))
1218	return
1219	super(ExportPDFTranscriptPage, self).update()
1220	self.semester_dict = getUtility(IKofaUtils).SEMESTER_DICT
1221	self.level_dict = level_dict(self.context)
1222	self.session_dict = dict(
1223	[(item[1], item[0]) for item in academic_sessions()])
1224	self.studymode_dict = getUtility(IKofaUtils).STUDY_MODES_DICT
1225	return
1226
1227	@property
1228	def label(self):
1229	# Here we know that the cookie has been set
1230	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1231	return translate(_('Academic Transcript'),
1232	'waeup.kofa', target_language=portal_language)
1233
1234	def _sigsInFooter(self):
1235	return (_('CERTIFIED TRUE COPY'),)
1236
1237	def _signatures(self):
1238	return None
1239
1240	def render(self):
1241	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1242	Term = translate(_('Term'), 'waeup.kofa', target_language=portal_language)
1243	Code = translate(_('Code'), 'waeup.kofa', target_language=portal_language)
1244	Title = translate(_('Title'), 'waeup.kofa', target_language=portal_language)
1245	Cred = translate(_('Credits'), 'waeup.kofa', target_language=portal_language)
1246	Score = translate(_('Score'), 'waeup.kofa', target_language=portal_language)
1247	Grade = translate(_('Grade'), 'waeup.kofa', target_language=portal_language)
1248	studentview = StudentBasePDFFormPage(self.context.student,
1249	self.request, self.omit_fields)
1250	students_utils = getUtility(IStudentsUtils)
1251
1252	tableheader = [(Code,'code', 2.5),
1253	(Title,'title', 7),
1254	(Term, 'semester', 1.5),
1255	(Cred, 'credits', 1.5),
1256	(Score, 'score', 1.5),
1257	(Grade, 'grade', 1.5),
1258	]
1259
1260	return students_utils.renderPDFTranscript(
1261	self, 'transcript.pdf',
1262	self.context.student, studentview,
1263	omit_fields=self.omit_fields,
1264	tableheader=tableheader,
1265	signatures=self._signatures(),
1266	sigs_in_footer=self._sigsInFooter(),
1267	)
1268
1269	class StudentTransferFormPage(KofaAddFormPage):
1270	"""Page to transfer the student.
1271	"""
1272	grok.context(IStudent)
1273	grok.name('transfer')
1274	grok.require('waeup.manageStudent')
1275	label = _('Transfer student')
1276	form_fields = grok.AutoFields(IStudentStudyCourseTransfer).omit(
1277	'entry_mode', 'entry_session')
1278	pnav = 4
1279
1280	@jsaction(_('Transfer'))
1281	def transferStudent(self, **data):
1282	error = self.context.transfer(**data)
1283	if error == -1:
1284	self.flash(_('Current level does not match certificate levels.'),
1285	type="warning")
1286	elif error == -2:
1287	self.flash(_('Former study course record incomplete.'),
1288	type="warning")
1289	elif error == -3:
1290	self.flash(_('Maximum number of transfers exceeded.'),
1291	type="warning")
1292	else:
1293	self.flash(_('Successfully transferred.'))
1294	return
1295
1296	class RevertTransferFormPage(KofaEditFormPage):
1297	"""View that reverts the previous transfer.
1298	"""
1299	grok.context(IStudent)
1300	grok.name('revert_transfer')
1301	grok.require('waeup.manageStudent')
1302	grok.template('reverttransfer')
1303	label = _('Revert previous transfer')
1304
1305	def update(self):
1306	if not self.context.has_key('studycourse_1'):
1307	self.flash(_('No previous transfer.'), type="warning")
1308	self.redirect(self.url(self.context))
1309	return
1310	return
1311
1312	@jsaction(_('Revert now'))
1313	def transferStudent(self, **data):
1314	self.context.revert_transfer()
1315	self.flash(_('Previous transfer reverted.'))
1316	self.redirect(self.url(self.context, 'studycourse'))
1317	return
1318
1319	class StudyLevelDisplayFormPage(KofaDisplayFormPage):
1320	""" Page to display student study levels
1321	"""
1322	grok.context(IStudentStudyLevel)
1323	grok.name('index')
1324	grok.require('waeup.viewStudent')
1325	form_fields = grok.AutoFields(IStudentStudyLevel).omit('level')
1326	form_fields[
1327	'validation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1328	grok.template('studylevelpage')
1329	pnav = 4
1330
1331	def update(self):
1332	super(StudyLevelDisplayFormPage, self).update()
1333	return
1334
1335	@property
1336	def translated_values(self):
1337	return translated_values(self)
1338
1339	@property
1340	def label(self):
1341	# Here we know that the cookie has been set
1342	lang = self.request.cookies.get('kofa.language')
1343	level_title = translate(self.context.level_title, 'waeup.kofa',
1344	target_language=lang)
1345	return _('${a}: Study Level ${b}', mapping = {
1346	'a':self.context.student.display_fullname,
1347	'b':level_title})
1348
1349	class ExportPDFCourseRegistrationSlipPage(UtilityView, grok.View):
1350	"""Deliver a PDF slip of the context.
1351	"""
1352	grok.context(IStudentStudyLevel)
1353	grok.name('course_registration_slip.pdf')
1354	grok.require('waeup.viewStudent')
1355	form_fields = grok.AutoFields(IStudentStudyLevel).omit('level')
1356	form_fields[
1357	'validation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1358	prefix = 'form'
1359	omit_fields = (
1360	'password', 'suspended', 'phone', 'date_of_birth',
1361	'adm_code', 'sex', 'suspended_comment', 'current_level')
1362
1363	@property
1364	def title(self):
1365	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1366	return translate(_('Level Data'), 'waeup.kofa',
1367	target_language=portal_language)
1368
1369	@property
1370	def label(self):
1371	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1372	lang = self.request.cookies.get('kofa.language', portal_language)
1373	level_title = translate(self.context.level_title, 'waeup.kofa',
1374	target_language=lang)
1375	return translate(_('Course Registration Slip'),
1376	'waeup.kofa', target_language=portal_language) \
1377	+ ' %s' % level_title
1378
1379	@property
1380	def tabletitle(self):
1381	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1382	tabletitle = []
1383	tabletitle.append(translate(_('1st Semester Courses'), 'waeup.kofa',
1384	target_language=portal_language))
1385	tabletitle.append(translate(_('2nd Semester Courses'), 'waeup.kofa',
1386	target_language=portal_language))
1387	tabletitle.append(translate(_('Level Courses'), 'waeup.kofa',
1388	target_language=portal_language))
1389	return tabletitle
1390
1391	def render(self):
1392	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1393	Term = translate(_('Term'), 'waeup.kofa', target_language=portal_language)
1394	Code = translate(_('Code'), 'waeup.kofa', target_language=portal_language)
1395	Title = translate(_('Title'), 'waeup.kofa', target_language=portal_language)
1396	Dept = translate(_('Dept.'), 'waeup.kofa', target_language=portal_language)
1397	Faculty = translate(_('Faculty'), 'waeup.kofa', target_language=portal_language)
1398	Cred = translate(_('Cred.'), 'waeup.kofa', target_language=portal_language)
1399	#Mand = translate(_('Requ.'), 'waeup.kofa', target_language=portal_language)
1400	Score = translate(_('Score'), 'waeup.kofa', target_language=portal_language)
1401	Grade = translate(_('Grade'), 'waeup.kofa', target_language=portal_language)
1402	studentview = StudentBasePDFFormPage(self.context.student,
1403	self.request, self.omit_fields)
1404	students_utils = getUtility(IStudentsUtils)
1405
1406	tabledata = []
1407	tableheader = []
1408	contenttitle = []
1409	for i in range(1,7):
1410	tabledata.append(sorted(
1411	[value for value in self.context.values() if value.semester == i],
1412	key=lambda value: str(value.semester) + value.code))
1413	tableheader.append([(Code,'code', 2.5),
1414	(Title,'title', 5),
1415	(Dept,'dcode', 1.5), (Faculty,'fcode', 1.5),
1416	(Cred, 'credits', 1.5),
1417	#(Mand, 'mandatory', 1.5),
1418	(Score, 'score', 1.5),
1419	(Grade, 'grade', 1.5),
1420	#('Auto', 'automatic', 1.5)
1421	])
1422	return students_utils.renderPDF(
1423	self, 'course_registration_slip.pdf',
1424	self.context.student, studentview,
1425	tableheader=tableheader,
1426	tabledata=tabledata,
1427	omit_fields=self.omit_fields
1428	)
1429
1430	class StudyLevelManageFormPage(KofaEditFormPage):
1431	""" Page to edit the student study level data
1432	"""
1433	grok.context(IStudentStudyLevel)
1434	grok.name('manage')
1435	grok.require('waeup.manageStudent')
1436	grok.template('studylevelmanagepage')
1437	form_fields = grok.AutoFields(IStudentStudyLevel).omit(
1438	'validation_date', 'validated_by', 'total_credits', 'gpa', 'level')
1439	pnav = 4
1440	taboneactions = [_('Save'),_('Cancel')]
1441	tabtwoactions = [_('Add course ticket'),
1442	_('Remove selected tickets'),_('Cancel')]
1443	placeholder = _('Enter valid course code')
1444
1445	def update(self, ADD=None, course=None):
1446	if not self.context.__parent__.is_current:
1447	emit_lock_message(self)
1448	return
1449	super(StudyLevelManageFormPage, self).update()
1450	if ADD is not None:
1451	if not course:
1452	self.flash(_('No valid course code entered.'), type="warning")
1453	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1454	return
1455	cat = queryUtility(ICatalog, name='courses_catalog')
1456	result = cat.searchResults(code=(course, course))
1457	if len(result) != 1:
1458	self.flash(_('Course not found.'), type="warning")
1459	else:
1460	course = list(result)[0]
1461	addCourseTicket(self, course)
1462	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1463	return
1464
1465	@property
1466	def translated_values(self):
1467	return translated_values(self)
1468
1469	@property
1470	def label(self):
1471	# Here we know that the cookie has been set
1472	lang = self.request.cookies.get('kofa.language')
1473	level_title = translate(self.context.level_title, 'waeup.kofa',
1474	target_language=lang)
1475	return _('Manage study level ${a}',
1476	mapping = {'a':level_title})
1477
1478	@action(_('Save'), style='primary')
1479	def save(self, **data):
1480	msave(self, **data)
1481	return
1482
1483	@jsaction(_('Remove selected tickets'))
1484	def delCourseTicket(self, **data):
1485	form = self.request.form
1486	if 'val_id' in form:
1487	child_id = form['val_id']
1488	else:
1489	self.flash(_('No ticket selected.'), type="warning")
1490	self.redirect(self.url(self.context, '@@manage')+'#tab2')
1491	return
1492	if not isinstance(child_id, list):
1493	child_id = [child_id]
1494	deleted = []
1495	for id in child_id:
1496	del self.context[id]
1497	deleted.append(id)
1498	if len(deleted):
1499	self.flash(_('Successfully removed: ${a}',
1500	mapping = {'a':', '.join(deleted)}))
1501	self.context.writeLogMessage(
1502	self,'removed: %s at %s' %
1503	(', '.join(deleted), self.context.level))
1504	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1505	return
1506
1507	class ValidateCoursesPage(UtilityView, grok.View):
1508	""" Validate course list by course adviser
1509	"""
1510	grok.context(IStudentStudyLevel)
1511	grok.name('validate_courses')
1512	grok.require('waeup.validateStudent')
1513
1514	def update(self):
1515	if not self.context.__parent__.is_current:
1516	emit_lock_message(self)
1517	return
1518	if str(self.context.__parent__.current_level) != self.context.__name__:
1519	self.flash(_('This level does not correspond current level.'),
1520	type="danger")
1521	elif self.context.student.state == REGISTERED:
1522	IWorkflowInfo(self.context.student).fireTransition(
1523	'validate_courses')
1524	self.flash(_('Course list has been validated.'))
1525	else:
1526	self.flash(_('Student is in the wrong state.'), type="warning")
1527	self.redirect(self.url(self.context))
1528	return
1529
1530	def render(self):
1531	return
1532
1533	class RejectCoursesPage(UtilityView, grok.View):
1534	""" Reject course list by course adviser
1535	"""
1536	grok.context(IStudentStudyLevel)
1537	grok.name('reject_courses')
1538	grok.require('waeup.validateStudent')
1539
1540	def update(self):
1541	if not self.context.__parent__.is_current:
1542	emit_lock_message(self)
1543	return
1544	if str(self.context.__parent__.current_level) != self.context.__name__:
1545	self.flash(_('This level does not correspond current level.'),
1546	type="danger")
1547	self.redirect(self.url(self.context))
1548	return
1549	elif self.context.student.state == VALIDATED:
1550	IWorkflowInfo(self.context.student).fireTransition('reset8')
1551	message = _('Course list request has been annulled.')
1552	self.flash(message)
1553	elif self.context.student.state == REGISTERED:
1554	IWorkflowInfo(self.context.student).fireTransition('reset7')
1555	message = _('Course list request has been rejected.')
1556	self.flash(message)
1557	else:
1558	self.flash(_('Student is in the wrong state.'), type="warning")
1559	self.redirect(self.url(self.context))
1560	return
1561	args = {'subject':message}
1562	self.redirect(self.url(self.context.student) +
1563	'/contactstudent?%s' % urlencode(args))
1564	return
1565
1566	def render(self):
1567	return
1568
1569	class CourseTicketAddFormPage(KofaAddFormPage):
1570	"""Add a course ticket.
1571	"""
1572	grok.context(IStudentStudyLevel)
1573	grok.name('add')
1574	grok.require('waeup.manageStudent')
1575	label = _('Add course ticket')
1576	form_fields = grok.AutoFields(ICourseTicketAdd)
1577	pnav = 4
1578
1579	def update(self):
1580	if not self.context.__parent__.is_current:
1581	emit_lock_message(self)
1582	return
1583	super(CourseTicketAddFormPage, self).update()
1584	return
1585
1586	@action(_('Add course ticket'), style='primary')
1587	def addCourseTicket(self, **data):
1588	course = data['course']
1589	success = addCourseTicket(self, course)
1590	if success:
1591	self.redirect(self.url(self.context, u'@@manage')+'#tab2')
1592	return
1593
1594	@action(_('Cancel'), validator=NullValidator)
1595	def cancel(self, **data):
1596	self.redirect(self.url(self.context))
1597
1598	class CourseTicketDisplayFormPage(KofaDisplayFormPage):
1599	""" Page to display course tickets
1600	"""
1601	grok.context(ICourseTicket)
1602	grok.name('index')
1603	grok.require('waeup.viewStudent')
1604	form_fields = grok.AutoFields(ICourseTicket)
1605	grok.template('courseticketpage')
1606	pnav = 4
1607
1608	@property
1609	def label(self):
1610	return _('${a}: Course Ticket ${b}', mapping = {
1611	'a':self.context.student.display_fullname,
1612	'b':self.context.code})
1613
1614	class CourseTicketManageFormPage(KofaEditFormPage):
1615	""" Page to manage course tickets
1616	"""
1617	grok.context(ICourseTicket)
1618	grok.name('manage')
1619	grok.require('waeup.manageStudent')
1620	form_fields = grok.AutoFields(ICourseTicket)
1621	form_fields['title'].for_display = True
1622	form_fields['fcode'].for_display = True
1623	form_fields['dcode'].for_display = True
1624	form_fields['semester'].for_display = True
1625	form_fields['passmark'].for_display = True
1626	form_fields['credits'].for_display = True
1627	form_fields['mandatory'].for_display = False
1628	form_fields['automatic'].for_display = True
1629	form_fields['carry_over'].for_display = True
1630	pnav = 4
1631	grok.template('courseticketmanagepage')
1632
1633	@property
1634	def label(self):
1635	return _('Manage course ticket ${a}', mapping = {'a':self.context.code})
1636
1637	@action('Save', style='primary')
1638	def save(self, **data):
1639	msave(self, **data)
1640	return
1641
1642	class PaymentsManageFormPage(KofaEditFormPage):
1643	""" Page to manage the student payments
1644
1645	This manage form page is for both students and students officers.
1646	"""
1647	grok.context(IStudentPaymentsContainer)
1648	grok.name('index')
1649	grok.require('waeup.viewStudent')
1650	form_fields = grok.AutoFields(IStudentPaymentsContainer)
1651	grok.template('paymentsmanagepage')
1652	pnav = 4
1653
1654	@property
1655	def manage_payments_allowed(self):
1656	return checkPermission('waeup.payStudent', self.context)
1657
1658	def unremovable(self, ticket):
1659	usertype = getattr(self.request.principal, 'user_type', None)
1660	if not usertype:
1661	return False
1662	if not self.manage_payments_allowed:
1663	return True
1664	return (self.request.principal.user_type == 'student' and ticket.r_code)
1665
1666	@property
1667	def label(self):
1668	return _('${a}: Payments',
1669	mapping = {'a':self.context.__parent__.display_fullname})
1670
1671	@jsaction(_('Remove selected tickets'))
1672	def delPaymentTicket(self, **data):
1673	form = self.request.form
1674	if 'val_id' in form:
1675	child_id = form['val_id']
1676	else:
1677	self.flash(_('No payment selected.'), type="warning")
1678	self.redirect(self.url(self.context))
1679	return
1680	if not isinstance(child_id, list):
1681	child_id = [child_id]
1682	deleted = []
1683	for id in child_id:
1684	# Students are not allowed to remove used payment tickets
1685	ticket = self.context.get(id, None)
1686	if ticket is not None and not self.unremovable(ticket):
1687	del self.context[id]
1688	deleted.append(id)
1689	if len(deleted):
1690	self.flash(_('Successfully removed: ${a}',
1691	mapping = {'a': ', '.join(deleted)}))
1692	self.context.writeLogMessage(
1693	self,'removed: %s' % ', '.join(deleted))
1694	self.redirect(self.url(self.context))
1695	return
1696
1697	#@action(_('Add online payment ticket'))
1698	#def addPaymentTicket(self, **data):
1699	# self.redirect(self.url(self.context, '@@addop'))
1700
1701	class OnlinePaymentAddFormPage(KofaAddFormPage):
1702	""" Page to add an online payment ticket
1703	"""
1704	grok.context(IStudentPaymentsContainer)
1705	grok.name('addop')
1706	grok.template('onlinepaymentaddform')
1707	grok.require('waeup.payStudent')
1708	form_fields = grok.AutoFields(IStudentOnlinePayment).select(
1709	'p_category')
1710	label = _('Add online payment')
1711	pnav = 4
1712
1713	@property
1714	def selectable_categories(self):
1715	categories = getUtility(IKofaUtils).SELECTABLE_PAYMENT_CATEGORIES
1716	return sorted(categories.items())
1717
1718	@action(_('Create ticket'), style='primary')
1719	def createTicket(self, **data):
1720	p_category = data['p_category']
1721	previous_session = data.get('p_session', None)
1722	previous_level = data.get('p_level', None)
1723	student = self.context.__parent__
1724	# The hostel_application payment category is temporarily used
1725	# by Uniben.
1726	if p_category in ('bed_allocation', 'hostel_application') and student[
1727	'studycourse'].current_session != grok.getSite()[
1728	'hostels'].accommodation_session:
1729	self.flash(
1730	_('Your current session does not match ' + \
1731	'accommodation session.'), type="danger")
1732	return
1733	if 'maintenance' in p_category:
1734	current_session = str(student['studycourse'].current_session)
1735	if not current_session in student['accommodation']:
1736	self.flash(_('You have not yet booked accommodation.'),
1737	type="warning")
1738	return
1739	students_utils = getUtility(IStudentsUtils)
1740	error, payment = students_utils.setPaymentDetails(
1741	p_category, student, previous_session, previous_level)
1742	if error is not None:
1743	self.flash(error, type="danger")
1744	return
1745	self.context[payment.p_id] = payment
1746	self.flash(_('Payment ticket created.'))
1747	self.context.writeLogMessage(self,'added: %s' % payment.p_id)
1748	self.redirect(self.url(self.context))
1749	return
1750
1751	@action(_('Cancel'), validator=NullValidator)
1752	def cancel(self, **data):
1753	self.redirect(self.url(self.context))
1754
1755	class PreviousPaymentAddFormPage(KofaAddFormPage):
1756	""" Page to add an online payment ticket for previous sessions
1757	"""
1758	grok.context(IStudentPaymentsContainer)
1759	grok.name('addpp')
1760	grok.require('waeup.payStudent')
1761	form_fields = grok.AutoFields(IStudentPreviousPayment)
1762	label = _('Add previous session online payment')
1763	pnav = 4
1764
1765	def update(self):
1766	if self.context.student.before_payment:
1767	self.flash(_("No previous payment to be made."), type="warning")
1768	self.redirect(self.url(self.context))
1769	super(PreviousPaymentAddFormPage, self).update()
1770	return
1771
1772	@action(_('Create ticket'), style='primary')
1773	def createTicket(self, **data):
1774	p_category = data['p_category']
1775	previous_session = data.get('p_session', None)
1776	previous_level = data.get('p_level', None)
1777	student = self.context.__parent__
1778	students_utils = getUtility(IStudentsUtils)
1779	error, payment = students_utils.setPaymentDetails(
1780	p_category, student, previous_session, previous_level)
1781	if error is not None:
1782	self.flash(error, type="danger")
1783	return
1784	self.context[payment.p_id] = payment
1785	self.flash(_('Payment ticket created.'))
1786	self.redirect(self.url(self.context))
1787	return
1788
1789	@action(_('Cancel'), validator=NullValidator)
1790	def cancel(self, **data):
1791	self.redirect(self.url(self.context))
1792
1793	class BalancePaymentAddFormPage(KofaAddFormPage):
1794	""" Page to add an online payment ticket for balance sessions
1795	"""
1796	grok.context(IStudentPaymentsContainer)
1797	grok.name('addbp')
1798	grok.require('waeup.manageStudent')
1799	form_fields = grok.AutoFields(IStudentBalancePayment)
1800	label = _('Add balance')
1801	pnav = 4
1802
1803	@action(_('Create ticket'), style='primary')
1804	def createTicket(self, **data):
1805	p_category = data['p_category']
1806	balance_session = data.get('balance_session', None)
1807	balance_level = data.get('balance_level', None)
1808	balance_amount = data.get('balance_amount', None)
1809	student = self.context.__parent__
1810	students_utils = getUtility(IStudentsUtils)
1811	error, payment = students_utils.setBalanceDetails(
1812	p_category, student, balance_session,
1813	balance_level, balance_amount)
1814	if error is not None:
1815	self.flash(error, type="danger")
1816	return
1817	self.context[payment.p_id] = payment
1818	self.flash(_('Payment ticket created.'))
1819	self.context.writeLogMessage(self,'added: %s' % payment.p_id)
1820	self.redirect(self.url(self.context))
1821	return
1822
1823	@action(_('Cancel'), validator=NullValidator)
1824	def cancel(self, **data):
1825	self.redirect(self.url(self.context))
1826
1827	class OnlinePaymentDisplayFormPage(KofaDisplayFormPage):
1828	""" Page to view an online payment ticket
1829	"""
1830	grok.context(IStudentOnlinePayment)
1831	grok.name('index')
1832	grok.require('waeup.viewStudent')
1833	form_fields = grok.AutoFields(IStudentOnlinePayment).omit('p_item')
1834	form_fields[
1835	'creation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1836	form_fields[
1837	'payment_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1838	pnav = 4
1839
1840	@property
1841	def label(self):
1842	return _('${a}: Online Payment Ticket ${b}', mapping = {
1843	'a':self.context.student.display_fullname,
1844	'b':self.context.p_id})
1845
1846	class OnlinePaymentApprovePage(UtilityView, grok.View):
1847	""" Callback view
1848	"""
1849	grok.context(IStudentOnlinePayment)
1850	grok.name('approve')
1851	grok.require('waeup.managePortal')
1852
1853	def update(self):
1854	flashtype, msg, log = self.context.approveStudentPayment()
1855	if log is not None:
1856	# Add log message to students.log
1857	self.context.writeLogMessage(self,log)
1858	# Add log message to payments.log
1859	self.context.logger.info(
1860	'%s,%s,%s,%s,%s,,,,,,' % (
1861	self.context.student.student_id,
1862	self.context.p_id, self.context.p_category,
1863	self.context.amount_auth, self.context.r_code))
1864	self.flash(msg, type=flashtype)
1865	return
1866
1867	def render(self):
1868	self.redirect(self.url(self.context, '@@index'))
1869	return
1870
1871	class OnlinePaymentFakeApprovePage(OnlinePaymentApprovePage):
1872	""" Approval view for students.
1873
1874	This view is used for browser tests only and
1875	must be neutralized in custom pages!
1876	"""
1877
1878	grok.name('fake_approve')
1879	grok.require('waeup.payStudent')
1880
1881	class ExportPDFPaymentSlipPage(UtilityView, grok.View):
1882	"""Deliver a PDF slip of the context.
1883	"""
1884	grok.context(IStudentOnlinePayment)
1885	grok.name('payment_slip.pdf')
1886	grok.require('waeup.viewStudent')
1887	form_fields = grok.AutoFields(IStudentOnlinePayment).omit('p_item')
1888	form_fields['creation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1889	form_fields['payment_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
1890	prefix = 'form'
1891	note = None
1892	omit_fields = (
1893	'password', 'suspended', 'phone', 'date_of_birth',
1894	'adm_code', 'sex', 'suspended_comment', 'current_level')
1895
1896	@property
1897	def title(self):
1898	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1899	return translate(_('Payment Data'), 'waeup.kofa',
1900	target_language=portal_language)
1901
1902	@property
1903	def label(self):
1904	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
1905	return translate(_('Online Payment Slip'),
1906	'waeup.kofa', target_language=portal_language) \
1907	+ ' %s' % self.context.p_id
1908
1909	def render(self):
1910	#if self.context.p_state != 'paid':
1911	# self.flash('Ticket not yet paid.')
1912	# self.redirect(self.url(self.context))
1913	# return
1914	studentview = StudentBasePDFFormPage(self.context.student,
1915	self.request, self.omit_fields)
1916	students_utils = getUtility(IStudentsUtils)
1917	return students_utils.renderPDF(self, 'payment_slip.pdf',
1918	self.context.student, studentview, note=self.note,
1919	omit_fields=self.omit_fields)
1920
1921
1922	class AccommodationManageFormPage(KofaEditFormPage):
1923	""" Page to manage bed tickets.
1924
1925	This manage form page is for both students and students officers.
1926	"""
1927	grok.context(IStudentAccommodation)
1928	grok.name('index')
1929	grok.require('waeup.handleAccommodation')
1930	form_fields = grok.AutoFields(IStudentAccommodation)
1931	grok.template('accommodationmanagepage')
1932	pnav = 4
1933	officers_only_actions = [_('Remove selected')]
1934
1935	@property
1936	def label(self):
1937	return _('${a}: Accommodation',
1938	mapping = {'a':self.context.__parent__.display_fullname})
1939
1940	@jsaction(_('Remove selected'))
1941	def delBedTickets(self, **data):
1942	if getattr(self.request.principal, 'user_type', None) == 'student':
1943	self.flash(_('You are not allowed to remove bed tickets.'),
1944	type="warning")
1945	self.redirect(self.url(self.context))
1946	return
1947	form = self.request.form
1948	if 'val_id' in form:
1949	child_id = form['val_id']
1950	else:
1951	self.flash(_('No bed ticket selected.'), type="warning")
1952	self.redirect(self.url(self.context))
1953	return
1954	if not isinstance(child_id, list):
1955	child_id = [child_id]
1956	deleted = []
1957	for id in child_id:
1958	del self.context[id]
1959	deleted.append(id)
1960	if len(deleted):
1961	self.flash(_('Successfully removed: ${a}',
1962	mapping = {'a':', '.join(deleted)}))
1963	self.context.writeLogMessage(
1964	self,'removed: % s' % ', '.join(deleted))
1965	self.redirect(self.url(self.context))
1966	return
1967
1968	@property
1969	def selected_actions(self):
1970	if getattr(self.request.principal, 'user_type', None) == 'student':
1971	return [action for action in self.actions
1972	if not action.label in self.officers_only_actions]
1973	return self.actions
1974
1975	class BedTicketAddPage(KofaPage):
1976	""" Page to add an online payment ticket
1977	"""
1978	grok.context(IStudentAccommodation)
1979	grok.name('add')
1980	grok.require('waeup.handleAccommodation')
1981	grok.template('enterpin')
1982	ac_prefix = 'HOS'
1983	label = _('Add bed ticket')
1984	pnav = 4
1985	buttonname = _('Create bed ticket')
1986	notice = ''
1987	with_ac = True
1988
1989	def update(self, SUBMIT=None):
1990	student = self.context.student
1991	students_utils = getUtility(IStudentsUtils)
1992	acc_details = students_utils.getAccommodationDetails(student)
1993	if acc_details.get('expired', False):
1994	startdate = acc_details.get('startdate')
1995	enddate = acc_details.get('enddate')
1996	if startdate and enddate:
1997	tz = getUtility(IKofaUtils).tzinfo
1998	startdate = to_timezone(
1999	startdate, tz).strftime("%d/%m/%Y %H:%M:%S")
2000	enddate = to_timezone(
2001	enddate, tz).strftime("%d/%m/%Y %H:%M:%S")
2002	self.flash(_("Outside booking period: ${a} - ${b}",
2003	mapping = {'a': startdate, 'b': enddate}), type="warning")
2004	else:
2005	self.flash(_("Outside booking period."), type="warning")
2006	self.redirect(self.url(self.context))
2007	return
2008	if not acc_details:
2009	self.flash(_("Your data are incomplete."), type="warning")
2010	self.redirect(self.url(self.context))
2011	return
2012	if not student.state in acc_details['allowed_states']:
2013	self.flash(_("You are in the wrong registration state."),
2014	type="warning")
2015	self.redirect(self.url(self.context))
2016	return
2017	if student['studycourse'].current_session != acc_details[
2018	'booking_session']:
2019	self.flash(
2020	_('Your current session does not match accommodation session.'),
2021	type="warning")
2022	self.redirect(self.url(self.context))
2023	return
2024	if str(acc_details['booking_session']) in self.context.keys():
2025	self.flash(
2026	_('You already booked a bed space in current ' \
2027	+ 'accommodation session.'), type="warning")
2028	self.redirect(self.url(self.context))
2029	return
2030	if self.with_ac:
2031	self.ac_series = self.request.form.get('ac_series', None)
2032	self.ac_number = self.request.form.get('ac_number', None)
2033	if SUBMIT is None:
2034	return
2035	if self.with_ac:
2036	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2037	code = get_access_code(pin)
2038	if not code:
2039	self.flash(_('Activation code is invalid.'), type="warning")
2040	return
2041	# Search and book bed
2042	cat = queryUtility(ICatalog, name='beds_catalog', default=None)
2043	entries = cat.searchResults(
2044	owner=(student.student_id,student.student_id))
2045	if len(entries):
2046	# If bed space has been manually allocated use this bed
2047	bed = [entry for entry in entries][0]
2048	# Safety belt for paranoids: Does this bed really exist on portal?
2049	# XXX: Can be remove if nobody complains.
2050	if bed.__parent__.__parent__ is None:
2051	self.flash(_('System error: Please contact the adminsitrator.'),
2052	type="danger")
2053	self.context.writeLogMessage(self, 'fatal error: %s' % bed.bed_id)
2054	return
2055	else:
2056	# else search for other available beds
2057	entries = cat.searchResults(
2058	bed_type=(acc_details['bt'],acc_details['bt']))
2059	available_beds = [
2060	entry for entry in entries if entry.owner == NOT_OCCUPIED]
2061	if available_beds:
2062	students_utils = getUtility(IStudentsUtils)
2063	bed = students_utils.selectBed(available_beds)
2064	# Safety belt for paranoids: Does this bed really exist in portal?
2065	# XXX: Can be remove if nobody complains.
2066	if bed.__parent__.__parent__ is None:
2067	self.flash(_('System error: Please contact the adminsitrator.'),
2068	type="warning")
2069	self.context.writeLogMessage(self, 'fatal error: %s' % bed.bed_id)
2070	return
2071	bed.bookBed(student.student_id)
2072	else:
2073	self.flash(_('There is no free bed in your category ${a}.',
2074	mapping = {'a':acc_details['bt']}), type="warning")
2075	return
2076	if self.with_ac:
2077	# Mark pin as used (this also fires a pin related transition)
2078	if code.state == USED:
2079	self.flash(_('Activation code has already been used.'),
2080	type="warning")
2081	return
2082	else:
2083	comment = _(u'invalidated')
2084	# Here we know that the ac is in state initialized so we do not
2085	# expect an exception, but the owner might be different
2086	if not invalidate_accesscode(
2087	pin,comment,self.context.student.student_id):
2088	self.flash(_('You are not the owner of this access code.'),
2089	type="warning")
2090	return
2091	# Create bed ticket
2092	bedticket = createObject(u'waeup.BedTicket')
2093	if self.with_ac:
2094	bedticket.booking_code = pin
2095	bedticket.booking_session = acc_details['booking_session']
2096	bedticket.bed_type = acc_details['bt']
2097	bedticket.bed = bed
2098	hall_title = bed.__parent__.hostel_name
2099	coordinates = bed.coordinates[1:]
2100	block, room_nr, bed_nr = coordinates
2101	bc = _('${a}, Block ${b}, Room ${c}, Bed ${d} (${e})', mapping = {
2102	'a':hall_title, 'b':block,
2103	'c':room_nr, 'd':bed_nr,
2104	'e':bed.bed_type})
2105	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
2106	bedticket.bed_coordinates = translate(
2107	bc, 'waeup.kofa',target_language=portal_language)
2108	self.context.addBedTicket(bedticket)
2109	self.context.writeLogMessage(self, 'booked: %s' % bed.bed_id)
2110	self.flash(_('Bed ticket created and bed booked: ${a}',
2111	mapping = {'a':bedticket.display_coordinates}))
2112	self.redirect(self.url(self.context))
2113	return
2114
2115	class BedTicketDisplayFormPage(KofaDisplayFormPage):
2116	""" Page to display bed tickets
2117	"""
2118	grok.context(IBedTicket)
2119	grok.name('index')
2120	grok.require('waeup.handleAccommodation')
2121	form_fields = grok.AutoFields(IBedTicket).omit('bed_coordinates')
2122	form_fields['booking_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
2123	pnav = 4
2124
2125	@property
2126	def label(self):
2127	return _('Bed Ticket for Session ${a}',
2128	mapping = {'a':self.context.getSessionString()})
2129
2130	class ExportPDFBedTicketSlipPage(UtilityView, grok.View):
2131	"""Deliver a PDF slip of the context.
2132	"""
2133	grok.context(IBedTicket)
2134	grok.name('bed_allocation_slip.pdf')
2135	grok.require('waeup.handleAccommodation')
2136	form_fields = grok.AutoFields(IBedTicket).omit('bed_coordinates')
2137	form_fields['booking_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
2138	prefix = 'form'
2139	omit_fields = (
2140	'password', 'suspended', 'phone', 'adm_code',
2141	'suspended_comment', 'date_of_birth', 'current_level')
2142
2143	@property
2144	def title(self):
2145	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
2146	return translate(_('Bed Allocation Data'), 'waeup.kofa',
2147	target_language=portal_language)
2148
2149	@property
2150	def label(self):
2151	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
2152	#return translate(_('Bed Allocation: '),
2153	# 'waeup.kofa', target_language=portal_language) \
2154	# + ' %s' % self.context.bed_coordinates
2155	return translate(_('Bed Allocation Slip'),
2156	'waeup.kofa', target_language=portal_language) \
2157	+ ' %s' % self.context.getSessionString()
2158
2159	def render(self):
2160	studentview = StudentBasePDFFormPage(self.context.student,
2161	self.request, self.omit_fields)
2162	students_utils = getUtility(IStudentsUtils)
2163	return students_utils.renderPDF(
2164	self, 'bed_allocation_slip.pdf',
2165	self.context.student, studentview,
2166	omit_fields=self.omit_fields)
2167
2168	class BedTicketRelocationPage(UtilityView, grok.View):
2169	""" Callback view
2170	"""
2171	grok.context(IBedTicket)
2172	grok.name('relocate')
2173	grok.require('waeup.manageHostels')
2174
2175	# Relocate student if student parameters have changed or the bed_type
2176	# of the bed has changed
2177	def update(self):
2178	student = self.context.student
2179	students_utils = getUtility(IStudentsUtils)
2180	acc_details = students_utils.getAccommodationDetails(student)
2181	if self.context.bed != None and \
2182	'reserved' in self.context.bed.bed_type:
2183	self.flash(_("Students in reserved beds can't be relocated."),
2184	type="warning")
2185	self.redirect(self.url(self.context))
2186	return
2187	if acc_details['bt'] == self.context.bed_type and \
2188	self.context.bed != None and \
2189	self.context.bed.bed_type == self.context.bed_type:
2190	self.flash(_("Student can't be relocated."), type="warning")
2191	self.redirect(self.url(self.context))
2192	return
2193	# Search a bed
2194	cat = queryUtility(ICatalog, name='beds_catalog', default=None)
2195	entries = cat.searchResults(
2196	owner=(student.student_id,student.student_id))
2197	if len(entries) and self.context.bed == None:
2198	# If booking has been cancelled but other bed space has been
2199	# manually allocated after cancellation use this bed
2200	new_bed = [entry for entry in entries][0]
2201	else:
2202	# Search for other available beds
2203	entries = cat.searchResults(
2204	bed_type=(acc_details['bt'],acc_details['bt']))
2205	available_beds = [
2206	entry for entry in entries if entry.owner == NOT_OCCUPIED]
2207	if available_beds:
2208	students_utils = getUtility(IStudentsUtils)
2209	new_bed = students_utils.selectBed(available_beds)
2210	new_bed.bookBed(student.student_id)
2211	else:
2212	self.flash(_('There is no free bed in your category ${a}.',
2213	mapping = {'a':acc_details['bt']}), type="warning")
2214	self.redirect(self.url(self.context))
2215	return
2216	# Release old bed if exists
2217	if self.context.bed != None:
2218	self.context.bed.owner = NOT_OCCUPIED
2219	notify(grok.ObjectModifiedEvent(self.context.bed))
2220	# Alocate new bed
2221	self.context.bed_type = acc_details['bt']
2222	self.context.bed = new_bed
2223	hall_title = new_bed.__parent__.hostel_name
2224	coordinates = new_bed.coordinates[1:]
2225	block, room_nr, bed_nr = coordinates
2226	bc = _('${a}, Block ${b}, Room ${c}, Bed ${d} (${e})', mapping = {
2227	'a':hall_title, 'b':block,
2228	'c':room_nr, 'd':bed_nr,
2229	'e':new_bed.bed_type})
2230	portal_language = getUtility(IKofaUtils).PORTAL_LANGUAGE
2231	self.context.bed_coordinates = translate(
2232	bc, 'waeup.kofa',target_language=portal_language)
2233	self.context.writeLogMessage(self, 'relocated: %s' % new_bed.bed_id)
2234	self.flash(_('Student relocated: ${a}',
2235	mapping = {'a':self.context.display_coordinates}))
2236	self.redirect(self.url(self.context))
2237	return
2238
2239	def render(self):
2240	return
2241
2242	class StudentHistoryPage(KofaPage):
2243	""" Page to display student history
2244	"""
2245	grok.context(IStudent)
2246	grok.name('history')
2247	grok.require('waeup.viewStudent')
2248	grok.template('studenthistory')
2249	pnav = 4
2250
2251	@property
2252	def label(self):
2253	return _('${a}: History', mapping = {'a':self.context.display_fullname})
2254
2255	# Pages for students only
2256
2257	class StudentBaseEditFormPage(KofaEditFormPage):
2258	""" View to edit student base data
2259	"""
2260	grok.context(IStudent)
2261	grok.name('edit_base')
2262	grok.require('waeup.handleStudent')
2263	form_fields = grok.AutoFields(IStudentBase).select(
2264	'email', 'phone')
2265	label = _('Edit base data')
2266	pnav = 4
2267
2268	@action(_('Save'), style='primary')
2269	def save(self, **data):
2270	msave(self, **data)
2271	return
2272
2273	class StudentChangePasswordPage(KofaEditFormPage):
2274	""" View to edit student passwords
2275	"""
2276	grok.context(IStudent)
2277	grok.name('change_password')
2278	grok.require('waeup.handleStudent')
2279	grok.template('change_password')
2280	label = _('Change password')
2281	pnav = 4
2282
2283	@action(_('Save'), style='primary')
2284	def save(self, **data):
2285	form = self.request.form
2286	password = form.get('change_password', None)
2287	password_ctl = form.get('change_password_repeat', None)
2288	if password:
2289	validator = getUtility(IPasswordValidator)
2290	errors = validator.validate_password(password, password_ctl)
2291	if not errors:
2292	IUserAccount(self.context).setPassword(password)
2293	# Unset temporary password
2294	self.context.temp_password = None
2295	self.context.writeLogMessage(self, 'saved: password')
2296	self.flash(_('Password changed.'))
2297	else:
2298	self.flash( ' '.join(errors), type="warning")
2299	return
2300
2301	class StudentFilesUploadPage(KofaPage):
2302	""" View to upload files by student
2303	"""
2304	grok.context(IStudent)
2305	grok.name('change_portrait')
2306	grok.require('waeup.uploadStudentFile')
2307	grok.template('filesuploadpage')
2308	label = _('Upload portrait')
2309	pnav = 4
2310
2311	def update(self):
2312	PWCHANGE_STATES = getUtility(IStudentsUtils).PWCHANGE_STATES
2313	if self.context.student.state not in PWCHANGE_STATES:
2314	emit_lock_message(self)
2315	return
2316	super(StudentFilesUploadPage, self).update()
2317	return
2318
2319	class StartClearancePage(KofaPage):
2320	grok.context(IStudent)
2321	grok.name('start_clearance')
2322	grok.require('waeup.handleStudent')
2323	grok.template('enterpin')
2324	label = _('Start clearance')
2325	ac_prefix = 'CLR'
2326	notice = ''
2327	pnav = 4
2328	buttonname = _('Start clearance now')
2329	with_ac = True
2330
2331	@property
2332	def all_required_fields_filled(self):
2333	if self.context.email and self.context.phone:
2334	return True
2335	return False
2336
2337	@property
2338	def portrait_uploaded(self):
2339	store = getUtility(IExtFileStore)
2340	if store.getFileByContext(self.context, attr=u'passport.jpg'):
2341	return True
2342	return False
2343
2344	def update(self, SUBMIT=None):
2345	if not self.context.state == ADMITTED:
2346	self.flash(_("Wrong state"), type="warning")
2347	self.redirect(self.url(self.context))
2348	return
2349	if not self.portrait_uploaded:
2350	self.flash(_("No portrait uploaded."), type="warning")
2351	self.redirect(self.url(self.context, 'change_portrait'))
2352	return
2353	if not self.all_required_fields_filled:
2354	self.flash(_("Not all required fields filled."), type="warning")
2355	self.redirect(self.url(self.context, 'edit_base'))
2356	return
2357	if self.with_ac:
2358	self.ac_series = self.request.form.get('ac_series', None)
2359	self.ac_number = self.request.form.get('ac_number', None)
2360	if SUBMIT is None:
2361	return
2362	if self.with_ac:
2363	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2364	code = get_access_code(pin)
2365	if not code:
2366	self.flash(_('Activation code is invalid.'), type="warning")
2367	return
2368	if code.state == USED:
2369	self.flash(_('Activation code has already been used.'),
2370	type="warning")
2371	return
2372	# Mark pin as used (this also fires a pin related transition)
2373	# and fire transition start_clearance
2374	comment = _(u"invalidated")
2375	# Here we know that the ac is in state initialized so we do not
2376	# expect an exception, but the owner might be different
2377	if not invalidate_accesscode(pin, comment, self.context.student_id):
2378	self.flash(_('You are not the owner of this access code.'),
2379	type="warning")
2380	return
2381	self.context.clr_code = pin
2382	IWorkflowInfo(self.context).fireTransition('start_clearance')
2383	self.flash(_('Clearance process has been started.'))
2384	self.redirect(self.url(self.context,'cedit'))
2385	return
2386
2387	class StudentClearanceEditFormPage(StudentClearanceManageFormPage):
2388	""" View to edit student clearance data by student
2389	"""
2390	grok.context(IStudent)
2391	grok.name('cedit')
2392	grok.require('waeup.handleStudent')
2393	label = _('Edit clearance data')
2394
2395	@property
2396	def form_fields(self):
2397	if self.context.is_postgrad:
2398	form_fields = grok.AutoFields(IPGStudentClearance).omit(
2399	'clearance_locked', 'clr_code', 'officer_comment')
2400	else:
2401	form_fields = grok.AutoFields(IUGStudentClearance).omit(
2402	'clearance_locked', 'clr_code', 'officer_comment')
2403	return form_fields
2404
2405	def update(self):
2406	if self.context.clearance_locked:
2407	emit_lock_message(self)
2408	return
2409	return super(StudentClearanceEditFormPage, self).update()
2410
2411	@action(_('Save'), style='primary')
2412	def save(self, **data):
2413	self.applyData(self.context, **data)
2414	self.flash(_('Clearance form has been saved.'))
2415	return
2416
2417	def dataNotComplete(self):
2418	"""To be implemented in the customization package.
2419	"""
2420	return False
2421
2422	@action(_('Save and request clearance'), style='primary')
2423	def requestClearance(self, **data):
2424	self.applyData(self.context, **data)
2425	if self.dataNotComplete():
2426	self.flash(self.dataNotComplete(), type="warning")
2427	return
2428	self.flash(_('Clearance form has been saved.'))
2429	if self.context.clr_code:
2430	self.redirect(self.url(self.context, 'request_clearance'))
2431	else:
2432	# We bypass the request_clearance page if student
2433	# has been imported in state 'clearance started' and
2434	# no clr_code was entered before.
2435	state = IWorkflowState(self.context).getState()
2436	if state != CLEARANCE:
2437	# This shouldn't happen, but the application officer
2438	# might have forgotten to lock the form after changing the state
2439	self.flash(_('This form cannot be submitted. Wrong state!'),
2440	type="danger")
2441	return
2442	IWorkflowInfo(self.context).fireTransition('request_clearance')
2443	self.flash(_('Clearance has been requested.'))
2444	self.redirect(self.url(self.context))
2445	return
2446
2447	class RequestClearancePage(KofaPage):
2448	grok.context(IStudent)
2449	grok.name('request_clearance')
2450	grok.require('waeup.handleStudent')
2451	grok.template('enterpin')
2452	label = _('Request clearance')
2453	notice = _('Enter the CLR access code used for starting clearance.')
2454	ac_prefix = 'CLR'
2455	pnav = 4
2456	buttonname = _('Request clearance now')
2457	with_ac = True
2458
2459	def update(self, SUBMIT=None):
2460	if self.with_ac:
2461	self.ac_series = self.request.form.get('ac_series', None)
2462	self.ac_number = self.request.form.get('ac_number', None)
2463	if SUBMIT is None:
2464	return
2465	if self.with_ac:
2466	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2467	if self.context.clr_code and self.context.clr_code != pin:
2468	self.flash(_("This isn't your CLR access code."), type="danger")
2469	return
2470	state = IWorkflowState(self.context).getState()
2471	if state != CLEARANCE:
2472	# This shouldn't happen, but the application officer
2473	# might have forgotten to lock the form after changing the state
2474	self.flash(_('This form cannot be submitted. Wrong state!'),
2475	type="danger")
2476	return
2477	IWorkflowInfo(self.context).fireTransition('request_clearance')
2478	self.flash(_('Clearance has been requested.'))
2479	self.redirect(self.url(self.context))
2480	return
2481
2482	class StartSessionPage(KofaPage):
2483	grok.context(IStudentStudyCourse)
2484	grok.name('start_session')
2485	grok.require('waeup.handleStudent')
2486	grok.template('enterpin')
2487	label = _('Start session')
2488	ac_prefix = 'SFE'
2489	notice = ''
2490	pnav = 4
2491	buttonname = _('Start now')
2492	with_ac = True
2493
2494	def update(self, SUBMIT=None):
2495	if not self.context.is_current:
2496	emit_lock_message(self)
2497	return
2498	super(StartSessionPage, self).update()
2499	if not self.context.next_session_allowed:
2500	self.flash(_("You are not entitled to start session."),
2501	type="warning")
2502	self.redirect(self.url(self.context))
2503	return
2504	if self.with_ac:
2505	self.ac_series = self.request.form.get('ac_series', None)
2506	self.ac_number = self.request.form.get('ac_number', None)
2507	if SUBMIT is None:
2508	return
2509	if self.with_ac:
2510	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2511	code = get_access_code(pin)
2512	if not code:
2513	self.flash(_('Activation code is invalid.'), type="warning")
2514	return
2515	# Mark pin as used (this also fires a pin related transition)
2516	if code.state == USED:
2517	self.flash(_('Activation code has already been used.'),
2518	type="warning")
2519	return
2520	else:
2521	comment = _(u"invalidated")
2522	# Here we know that the ac is in state initialized so we do not
2523	# expect an error, but the owner might be different
2524	if not invalidate_accesscode(
2525	pin,comment,self.context.student.student_id):
2526	self.flash(_('You are not the owner of this access code.'),
2527	type="warning")
2528	return
2529	try:
2530	if self.context.student.state == CLEARED:
2531	IWorkflowInfo(self.context.student).fireTransition(
2532	'pay_first_school_fee')
2533	elif self.context.student.state == RETURNING:
2534	IWorkflowInfo(self.context.student).fireTransition(
2535	'pay_school_fee')
2536	elif self.context.student.state == PAID:
2537	IWorkflowInfo(self.context.student).fireTransition(
2538	'pay_pg_fee')
2539	except ConstraintNotSatisfied:
2540	self.flash(_('An error occurred, please contact the system administrator.'),
2541	type="danger")
2542	return
2543	self.flash(_('Session started.'))
2544	self.redirect(self.url(self.context))
2545	return
2546
2547	class AddStudyLevelFormPage(KofaEditFormPage):
2548	""" Page for students to add current study levels
2549	"""
2550	grok.context(IStudentStudyCourse)
2551	grok.name('add')
2552	grok.require('waeup.handleStudent')
2553	grok.template('studyleveladdpage')
2554	form_fields = grok.AutoFields(IStudentStudyCourse)
2555	pnav = 4
2556
2557	@property
2558	def label(self):
2559	studylevelsource = StudyLevelSource().factory
2560	code = self.context.current_level
2561	title = studylevelsource.getTitle(self.context, code)
2562	return _('Add current level ${a}', mapping = {'a':title})
2563
2564	def update(self):
2565	if not self.context.is_current:
2566	emit_lock_message(self)
2567	return
2568	if self.context.student.state != PAID:
2569	emit_lock_message(self)
2570	return
2571	code = self.context.current_level
2572	if code is None:
2573	self.flash(_('Your data are incomplete'), type="danger")
2574	self.redirect(self.url(self.context))
2575	return
2576	super(AddStudyLevelFormPage, self).update()
2577	return
2578
2579	@action(_('Create course list now'), style='primary')
2580	def addStudyLevel(self, **data):
2581	studylevel = createObject(u'waeup.StudentStudyLevel')
2582	studylevel.level = self.context.current_level
2583	studylevel.level_session = self.context.current_session
2584	try:
2585	self.context.addStudentStudyLevel(
2586	self.context.certificate,studylevel)
2587	except KeyError:
2588	self.flash(_('This level exists.'), type="warning")
2589	except RequiredMissing:
2590	self.flash(_('Your data are incomplete'), type="danger")
2591	self.redirect(self.url(self.context))
2592	return
2593
2594	class StudyLevelEditFormPage(KofaEditFormPage):
2595	""" Page to edit the student study level data by students
2596	"""
2597	grok.context(IStudentStudyLevel)
2598	grok.name('edit')
2599	grok.require('waeup.editStudyLevel')
2600	grok.template('studyleveleditpage')
2601	pnav = 4
2602	placeholder = _('Enter valid course code')
2603
2604	def update(self, ADD=None, course=None):
2605	if not self.context.__parent__.is_current:
2606	emit_lock_message(self)
2607	return
2608	if self.context.student.state != PAID or \
2609	not self.context.is_current_level:
2610	emit_lock_message(self)
2611	return
2612	super(StudyLevelEditFormPage, self).update()
2613	if ADD is not None:
2614	if not course:
2615	self.flash(_('No valid course code entered.'), type="warning")
2616	return
2617	cat = queryUtility(ICatalog, name='courses_catalog')
2618	result = cat.searchResults(code=(course, course))
2619	if len(result) != 1:
2620	self.flash(_('Course not found.'), type="warning")
2621	return
2622	course = list(result)[0]
2623	addCourseTicket(self, course)
2624	return
2625
2626	@property
2627	def label(self):
2628	# Here we know that the cookie has been set
2629	lang = self.request.cookies.get('kofa.language')
2630	level_title = translate(self.context.level_title, 'waeup.kofa',
2631	target_language=lang)
2632	return _('Edit course list of ${a}',
2633	mapping = {'a':level_title})
2634
2635	@property
2636	def translated_values(self):
2637	return translated_values(self)
2638
2639	def _delCourseTicket(self, **data):
2640	form = self.request.form
2641	if 'val_id' in form:
2642	child_id = form['val_id']
2643	else:
2644	self.flash(_('No ticket selected.'), type="warning")
2645	self.redirect(self.url(self.context, '@@edit'))
2646	return
2647	if not isinstance(child_id, list):
2648	child_id = [child_id]
2649	deleted = []
2650	for id in child_id:
2651	# Students are not allowed to remove core tickets
2652	if id in self.context and \
2653	self.context[id].removable_by_student:
2654	del self.context[id]
2655	deleted.append(id)
2656	if len(deleted):
2657	self.flash(_('Successfully removed: ${a}',
2658	mapping = {'a':', '.join(deleted)}))
2659	self.context.writeLogMessage(
2660	self,'removed: %s at %s' %
2661	(', '.join(deleted), self.context.level))
2662	self.redirect(self.url(self.context, u'@@edit'))
2663	return
2664
2665	@jsaction(_('Remove selected tickets'))
2666	def delCourseTicket(self, **data):
2667	self._delCourseTicket(**data)
2668	return
2669
2670	def _registerCourses(self, **data):
2671	if self.context.student.is_postgrad and \
2672	not self.context.student.is_special_postgrad:
2673	self.flash(_(
2674	"You are a postgraduate student, "
2675	"your course list can't bee registered."), type="warning")
2676	self.redirect(self.url(self.context))
2677	return
2678	students_utils = getUtility(IStudentsUtils)
2679	max_credits = students_utils.maxCredits(self.context)
2680	if max_credits and self.context.total_credits > max_credits:
2681	self.flash(_('Maximum credits of ${a} exceeded.',
2682	mapping = {'a':max_credits}), type="warning")
2683	return
2684	if not self.context.course_registration_allowed:
2685	self.flash(_(
2686	"Course registration has ended. "
2687	"Please pay the late registration fee."), type="warning")
2688	#self.redirect(self.url(self.context))
2689	return
2690	IWorkflowInfo(self.context.student).fireTransition(
2691	'register_courses')
2692	self.flash(_('Course list has been registered.'))
2693	self.redirect(self.url(self.context))
2694	return
2695
2696	@action(_('Register course list'), style='primary',
2697	warning=_('You can not edit your course list after registration.'
2698	' You really want to register?'))
2699	def registerCourses(self, **data):
2700	self._registerCourses(**data)
2701	return
2702
2703	class CourseTicketAddFormPage2(CourseTicketAddFormPage):
2704	"""Add a course ticket by student.
2705	"""
2706	grok.name('ctadd')
2707	grok.require('waeup.handleStudent')
2708	form_fields = grok.AutoFields(ICourseTicketAdd)
2709
2710	def update(self):
2711	if self.context.student.state != PAID or \
2712	not self.context.is_current_level:
2713	emit_lock_message(self)
2714	return
2715	super(CourseTicketAddFormPage2, self).update()
2716	return
2717
2718	@action(_('Add course ticket'))
2719	def addCourseTicket(self, **data):
2720	# Safety belt
2721	if self.context.student.state != PAID:
2722	return
2723	course = data['course']
2724	success = addCourseTicket(self, course)
2725	if success:
2726	self.redirect(self.url(self.context, u'@@edit'))
2727	return
2728
2729	class SetPasswordPage(KofaPage):
2730	grok.context(IKofaObject)
2731	grok.name('setpassword')
2732	grok.require('waeup.Anonymous')
2733	grok.template('setpassword')
2734	label = _('Set password for first-time login')
2735	ac_prefix = 'PWD'
2736	pnav = 0
2737	set_button = _('Set')
2738
2739	def update(self, SUBMIT=None):
2740	self.reg_number = self.request.form.get('reg_number', None)
2741	self.ac_series = self.request.form.get('ac_series', None)
2742	self.ac_number = self.request.form.get('ac_number', None)
2743
2744	if SUBMIT is None:
2745	return
2746	hitlist = search(query=self.reg_number,
2747	searchtype='reg_number', view=self)
2748	if not hitlist:
2749	self.flash(_('No student found.'), type="warning")
2750	return
2751	if len(hitlist) != 1: # Cannot happen but anyway
2752	self.flash(_('More than one student found.'), type="warning")
2753	return
2754	student = hitlist[0].context
2755	self.student_id = student.student_id
2756	student_pw = student.password
2757	pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
2758	code = get_access_code(pin)
2759	if not code:
2760	self.flash(_('Access code is invalid.'), type="warning")
2761	return
2762	if student_pw and pin == student.adm_code:
2763	self.flash(_(
2764	'Password has already been set. Your Student Id is ${a}',
2765	mapping = {'a':self.student_id}))
2766	return
2767	elif student_pw:
2768	self.flash(
2769	_('Password has already been set. You are using the ' +
2770	'wrong Access Code.'), type="warning")
2771	return
2772	# Mark pin as used (this also fires a pin related transition)
2773	# and set student password
2774	if code.state == USED:
2775	self.flash(_('Access code has already been used.'), type="warning")
2776	return
2777	else:
2778	comment = _(u"invalidated")
2779	# Here we know that the ac is in state initialized so we do not
2780	# expect an exception
2781	invalidate_accesscode(pin,comment)
2782	IUserAccount(student).setPassword(self.ac_number)
2783	student.adm_code = pin
2784	self.flash(_('Password has been set. Your Student Id is ${a}',
2785	mapping = {'a':self.student_id}))
2786	return
2787
2788	class StudentRequestPasswordPage(KofaAddFormPage):
2789	"""Captcha'd registration page for applicants.
2790	"""
2791	grok.name('requestpw')
2792	grok.require('waeup.Anonymous')
2793	grok.template('requestpw')
2794	form_fields = grok.AutoFields(IStudentRequestPW).select(
2795	'firstname','number','email')
2796	label = _('Request password for first-time login')
2797
2798	def update(self):
2799	# Handle captcha
2800	self.captcha = getUtility(ICaptchaManager).getCaptcha()
2801	self.captcha_result = self.captcha.verify(self.request)
2802	self.captcha_code = self.captcha.display(self.captcha_result.error_code)
2803	return
2804
2805	def _redirect(self, email, password, student_id):
2806	# Forward only email to landing page in base package.
2807	self.redirect(self.url(self.context, 'requestpw_complete',
2808	data = dict(email=email)))
2809	return
2810
2811	def _pw_used(self):
2812	# XXX: False if password has not been used. We need an extra
2813	# attribute which remembers if student logged in.
2814	return True
2815
2816	@action(_('Send login credentials to email address'), style='primary')
2817	def get_credentials(self, **data):
2818	if not self.captcha_result.is_valid:
2819	# Captcha will display error messages automatically.
2820	# No need to flash something.
2821	return
2822	number = data.get('number','')
2823	firstname = data.get('firstname','')
2824	cat = getUtility(ICatalog, name='students_catalog')
2825	results = list(
2826	cat.searchResults(reg_number=(number, number)))
2827	if not results:
2828	results = list(
2829	cat.searchResults(matric_number=(number, number)))
2830	if results:
2831	student = results[0]
2832	if getattr(student,'firstname',None) is None:
2833	self.flash(_('An error occurred.'), type="danger")
2834	return
2835	elif student.firstname.lower() != firstname.lower():
2836	# Don't tell the truth here. Anonymous must not
2837	# know that a record was found and only the firstname
2838	# verification failed.
2839	self.flash(_('No student record found.'), type="warning")
2840	return
2841	elif student.password is not None and self._pw_used:
2842	self.flash(_('Your password has already been set and used. '
2843	'Please proceed to the login page.'),
2844	type="warning")
2845	return
2846	# Store email address but nothing else.
2847	student.email = data['email']
2848	notify(grok.ObjectModifiedEvent(student))
2849	else:
2850	# No record found, this is the truth.
2851	self.flash(_('No student record found.'), type="warning")
2852	return
2853
2854	kofa_utils = getUtility(IKofaUtils)
2855	password = kofa_utils.genPassword()
2856	mandate = PasswordMandate()
2857	mandate.params['password'] = password
2858	mandate.params['user'] = student
2859	site = grok.getSite()
2860	site['mandates'].addMandate(mandate)
2861	# Send email with credentials
2862	args = {'mandate_id':mandate.mandate_id}
2863	mandate_url = self.url(site) + '/mandate?%s' % urlencode(args)
2864	url_info = u'Confirmation link: %s' % mandate_url
2865	msg = _('You have successfully requested a password for the')
2866	if kofa_utils.sendCredentials(IUserAccount(student),
2867	password, url_info, msg):
2868	email_sent = student.email
2869	else:
2870	email_sent = None
2871	self._redirect(email=email_sent, password=password,
2872	student_id=student.student_id)
2873	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
2874	self.context.logger.info(
2875	'%s - %s (%s) - %s' % (ob_class, number, student.student_id, email_sent))
2876	return
2877
2878	class StudentRequestPasswordEmailSent(KofaPage):
2879	"""Landing page after successful password request.
2880
2881	"""
2882	grok.name('requestpw_complete')
2883	grok.require('waeup.Public')
2884	grok.template('requestpwmailsent')
2885	label = _('Your password request was successful.')
2886
2887	def update(self, email=None, student_id=None, password=None):
2888	self.email = email
2889	self.password = password
2890	self.student_id = student_id
2891	return
2892
2893	class FilterStudentsInDepartmentPage(KofaPage):
2894	"""Page that filters and lists students.
2895	"""
2896	grok.context(IDepartment)
2897	grok.require('waeup.showStudents')
2898	grok.name('students')
2899	grok.template('filterstudentspage')
2900	pnav = 1
2901	session_label = _('Current Session')
2902	level_label = _('Current Level')
2903
2904	def label(self):
2905	return 'Students in %s' % self.context.longtitle
2906
2907	def _set_session_values(self):
2908	vocab_terms = academic_sessions_vocab.by_value.values()
2909	self.sessions = sorted(
2910	[(x.title, x.token) for x in vocab_terms], reverse=True)
2911	self.sessions += [('All Sessions', 'all')]
2912	return
2913
2914	def _set_level_values(self):
2915	vocab_terms = course_levels.by_value.values()
2916	self.levels = sorted(
2917	[(x.title, x.token) for x in vocab_terms])
2918	self.levels += [('All Levels', 'all')]
2919	return
2920
2921	def _searchCatalog(self, session, level):
2922	if level not in (10, 999, None):
2923	start_level = 100 * (level // 100)
2924	end_level = start_level + 90
2925	else:
2926	start_level = end_level = level
2927	cat = queryUtility(ICatalog, name='students_catalog')
2928	students = cat.searchResults(
2929	current_session=(session, session),
2930	current_level=(start_level, end_level),
2931	depcode=(self.context.code, self.context.code)
2932	)
2933	hitlist = []
2934	for student in students:
2935	hitlist.append(StudentQueryResultItem(student, view=self))
2936	return hitlist
2937
2938	def update(self, SHOW=None, session=None, level=None):
2939	self.parent_url = self.url(self.context.__parent__)
2940	self._set_session_values()
2941	self._set_level_values()
2942	self.hitlist = []
2943	self.session_default = session
2944	self.level_default = level
2945	if SHOW is not None:
2946	if session != 'all':
2947	self.session = int(session)
2948	self.session_string = '%s %s/%s' % (
2949	self.session_label, self.session, self.session+1)
2950	else:
2951	self.session = None
2952	self.session_string = _('in any session')
2953	if level != 'all':
2954	self.level = int(level)
2955	self.level_string = '%s %s' % (self.level_label, self.level)
2956	else:
2957	self.level = None
2958	self.level_string = _('at any level')
2959	self.hitlist = self._searchCatalog(self.session, self.level)
2960	if not self.hitlist:
2961	self.flash(_('No student found.'), type="warning")
2962	return
2963
2964	class FilterStudentsInCertificatePage(FilterStudentsInDepartmentPage):
2965	"""Page that filters and lists students.
2966	"""
2967	grok.context(ICertificate)
2968
2969	def label(self):
2970	return 'Students studying %s' % self.context.longtitle
2971
2972	def _searchCatalog(self, session, level):
2973	if level not in (10, 999, None):
2974	start_level = 100 * (level // 100)
2975	end_level = start_level + 90
2976	else:
2977	start_level = end_level = level
2978	cat = queryUtility(ICatalog, name='students_catalog')
2979	students = cat.searchResults(
2980	current_session=(session, session),
2981	current_level=(start_level, end_level),
2982	certcode=(self.context.code, self.context.code)
2983	)
2984	hitlist = []
2985	for student in students:
2986	hitlist.append(StudentQueryResultItem(student, view=self))
2987	return hitlist
2988
2989	class FilterStudentsInCoursePage(FilterStudentsInDepartmentPage):
2990	"""Page that filters and lists students.
2991	"""
2992	grok.context(ICourse)
2993
2994	session_label = _('Session')
2995	level_label = _('Level')
2996
2997	def label(self):
2998	return 'Students registered for %s' % self.context.longtitle
2999
3000	def _searchCatalog(self, session, level):
3001	if level not in (10, 999, None):
3002	start_level = 100 * (level // 100)
3003	end_level = start_level + 90
3004	else:
3005	start_level = end_level = level
3006	cat = queryUtility(ICatalog, name='coursetickets_catalog')
3007	coursetickets = cat.searchResults(
3008	session=(session, session),
3009	level=(start_level, end_level),
3010	code=(self.context.code, self.context.code)
3011	)
3012	hitlist = []
3013	for ticket in coursetickets:
3014	hitlist.append(StudentQueryResultItem(ticket.student, view=self))
3015	return list(set(hitlist))
3016
3017	class ClearAllStudentsInDepartmentPage(UtilityView, grok.View):
3018	""" Clear all students of a department in state 'clearance requested'.
3019	"""
3020	grok.context(IDepartment)
3021	grok.name('clearallstudents')
3022	grok.require('waeup.clearAllStudents')
3023
3024	def update(self):
3025	cat = queryUtility(ICatalog, name='students_catalog')
3026	students = cat.searchResults(
3027	depcode=(self.context.code, self.context.code),
3028	state=(REQUESTED, REQUESTED)
3029	)
3030	num = 0
3031	for student in students:
3032	if getUtility(IStudentsUtils).clearance_disabled_message(student):
3033	continue
3034	IWorkflowInfo(student).fireTransition('clear')
3035	num += 1
3036	self.flash(_('%d students have been cleared.' % num))
3037	self.redirect(self.url(self.context))
3038	return
3039
3040	def render(self):
3041	return
3042
3043
3044	class EditScoresPage(KofaPage):
3045	"""Page that filters and lists students.
3046	"""
3047	grok.context(ICourse)
3048	grok.require('waeup.editScores')
3049	grok.name('edit_scores')
3050	grok.template('editscorespage')
3051	pnav = 1
3052
3053	def label(self):
3054	session = academic_sessions_vocab.getTerm(
3055	self.current_academic_session).title
3056	return '%s tickets in academic session %s' % (
3057	self.context.code, session)
3058
3059	def _searchCatalog(self, session):
3060	cat = queryUtility(ICatalog, name='coursetickets_catalog')
3061	coursetickets = cat.searchResults(
3062	session=(session, session),
3063	code=(self.context.code, self.context.code)
3064	)
3065	return list(coursetickets)
3066
3067	def update(self, args, *kw):
3068	form = self.request.form
3069	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3070	self.current_academic_session = grok.getSite()[
3071	'configuration'].current_academic_session
3072	if self.context.__parent__.__parent__.score_editing_disabled:
3073	self.flash(_('Score editing disabled.'), type="warning")
3074	self.redirect(self.url(self.context))
3075	return
3076	if not self.current_academic_session:
3077	self.flash(_('Current academic session not set.'), type="warning")
3078	self.redirect(self.url(self.context))
3079	return
3080	self.tickets = self._searchCatalog(self.current_academic_session)
3081	editable_tickets = [
3082	ticket for ticket in self.tickets if ticket.editable_by_lecturer]
3083	if not self.tickets:
3084	self.flash(_('No student found.'), type="warning")
3085	self.redirect(self.url(self.context))
3086	return
3087	if 'UPDATE' in form:
3088	tno = 0
3089	error = ''
3090	if not editable_tickets:
3091	return
3092	scores = form['scores']
3093	if isinstance(scores, basestring):
3094	scores = [scores]
3095	for ticket in editable_tickets:
3096	score = ticket.score
3097	if scores[tno] == '':
3098	score = None
3099	else:
3100	try:
3101	score = int(scores[tno])
3102	except ValueError:
3103	error += '%s, ' % ticket.student.display_fullname
3104	if ticket.score != score:
3105	ticket.score = score
3106	ticket.student.__parent__.logger.info(
3107	'%s - %s %s/%s score updated (%s)' %
3108	(ob_class, ticket.student.student_id,
3109	ticket.level, ticket.code, score))
3110	#notify(grok.ObjectModifiedEvent(ticket))
3111	tno += 1
3112	if error:
3113	self.flash(_('Error: Score(s) of %s have not be updated. '
3114	'Only integers are allowed.' % error.strip(', ')),
3115	type="danger")
3116	return
3117
3118	class ExportJobContainerOverview(KofaPage):
3119	"""Page that lists active student data export jobs and provides links
3120	to discard or download CSV files.
3121
3122	"""
3123	grok.context(VirtualExportJobContainer)
3124	grok.require('waeup.showStudents')
3125	grok.name('index.html')
3126	grok.template('exportjobsindex')
3127	label = _('Student Data Exports')
3128	pnav = 1
3129	doclink = DOCLINK + '/datacenter/export.html#student-data-exporters'
3130
3131	def update(self, CREATE=None, DISCARD=None, job_id=None):
3132	if CREATE:
3133	self.redirect(self.url('@@exportconfig'))
3134	return
3135	if DISCARD and job_id:
3136	entry = self.context.entry_from_job_id(job_id)
3137	self.context.delete_export_entry(entry)
3138	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3139	self.context.logger.info(
3140	'%s - discarded: job_id=%s' % (ob_class, job_id))
3141	self.flash(_('Discarded export') + ' %s' % job_id)
3142	self.entries = doll_up(self, user=self.request.principal.id)
3143	return
3144
3145	class ExportJobContainerJobConfig(KofaPage):
3146	"""Page that configures a students export job.
3147
3148	This is a baseclass.
3149	"""
3150	grok.baseclass()
3151	grok.name('exportconfig')
3152	grok.require('waeup.showStudents')
3153	grok.template('exportconfig')
3154	label = _('Configure student data export')
3155	pnav = 1
3156	redirect_target = ''
3157	doclink = DOCLINK + '/datacenter/export.html#student-data-exporters'
3158
3159	def _set_session_values(self):
3160	vocab_terms = academic_sessions_vocab.by_value.values()
3161	self.sessions = sorted(
3162	[(x.title, x.token) for x in vocab_terms], reverse=True)
3163	self.sessions += [(_('All Sessions'), 'all')]
3164	return
3165
3166	def _set_level_values(self):
3167	vocab_terms = course_levels.by_value.values()
3168	self.levels = sorted(
3169	[(x.title, x.token) for x in vocab_terms])
3170	self.levels += [(_('All Levels'), 'all')]
3171	return
3172
3173	def _set_mode_values(self):
3174	utils = getUtility(IKofaUtils)
3175	self.modes = sorted([(value, key) for key, value in
3176	utils.STUDY_MODES_DICT.items()])
3177	self.modes +=[(_('All Modes'), 'all')]
3178	return
3179
3180	def _set_exporter_values(self):
3181	# We provide all student exporters, nothing else, yet.
3182	# Bursary or Department Officers don't have the general exportData
3183	# permission and are only allowed to export bursary or payments
3184	# overview data respectively. This is the only place where
3185	# waeup.exportBursaryData and waeup.exportPaymentsOverview
3186	# are used.
3187	exporters = []
3188	if not checkPermission('waeup.exportData', self.context):
3189	if checkPermission('waeup.exportBursaryData', self.context):
3190	exporters += [('Bursary Data', 'bursary')]
3191	if checkPermission('waeup.exportPaymentsOverview', self.context):
3192	exporters += [('Student Payments Overview', 'paymentsoverview')]
3193	self.exporters = exporters
3194	return
3195	STUDENT_EXPORTER_NAMES = getUtility(
3196	IStudentsUtils).STUDENT_EXPORTER_NAMES
3197	for name in STUDENT_EXPORTER_NAMES:
3198	util = getUtility(ICSVExporter, name=name)
3199	exporters.append((util.title, name),)
3200	self.exporters = exporters
3201	return
3202
3203	@property
3204	def faccode(self):
3205	return None
3206
3207	@property
3208	def depcode(self):
3209	return None
3210
3211	@property
3212	def certcode(self):
3213	return None
3214
3215	def update(self, START=None, session=None, level=None, mode=None,
3216	payments_start=None, payments_end=None,
3217	exporter=None):
3218	self._set_session_values()
3219	self._set_level_values()
3220	self._set_mode_values()
3221	self._set_exporter_values()
3222	if START is None:
3223	return
3224	utils = queryUtility(IKofaUtils)
3225	if not utils.expensive_actions_allowed():
3226	self.flash(_(
3227	"Currently, exporters cannot be started due to high "
3228	"system load. Please try again later."), type='danger')
3229	return
3230	if payments_start or payments_end:
3231	date_format = '%d/%m/%Y'
3232	try:
3233	dummy = datetime.strptime(payments_start, date_format)
3234	dummy = datetime.strptime(payments_end, date_format)
3235	except ValueError:
3236	self.flash(_('Payment dates do not match format d/m/Y.'),
3237	type="danger")
3238	return
3239	if session == 'all':
3240	session=None
3241	if level == 'all':
3242	level = None
3243	if mode == 'all':
3244	mode = None
3245	if payments_start == '':
3246	payments_start = None
3247	if payments_end == '':
3248	payments_end = None
3249	if (mode,
3250	level,
3251	session,
3252	self.faccode,
3253	self.depcode,
3254	self.certcode) == (None, None, None, None, None, None):
3255	# Export all students including those without certificate
3256	if payments_start:
3257	job_id = self.context.start_export_job(exporter,
3258	self.request.principal.id,
3259	payments_start = payments_start,
3260	payments_end = payments_end)
3261	else:
3262	job_id = self.context.start_export_job(exporter,
3263	self.request.principal.id)
3264	else:
3265	if payments_start:
3266	job_id = self.context.start_export_job(exporter,
3267	self.request.principal.id,
3268	current_session=session,
3269	current_level=level,
3270	current_mode=mode,
3271	faccode=self.faccode,
3272	depcode=self.depcode,
3273	certcode=self.certcode,
3274	payments_start = payments_start,
3275	payments_end = payments_end)
3276	else:
3277	job_id = self.context.start_export_job(exporter,
3278	self.request.principal.id,
3279	current_session=session,
3280	current_level=level,
3281	current_mode=mode,
3282	faccode=self.faccode,
3283	depcode=self.depcode,
3284	certcode=self.certcode)
3285	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3286	self.context.logger.info(
3287	'%s - exported: %s (%s, %s, %s, %s, %s, %s, %s, %s), job_id=%s'
3288	% (ob_class, exporter, session, level, mode, self.faccode,
3289	self.depcode, self.certcode, payments_start, payments_end, job_id))
3290	self.flash(_('Export started for students with') +
3291	' current_session=%s, current_level=%s, study_mode=%s' % (
3292	session, level, mode))
3293	self.redirect(self.url(self.redirect_target))
3294	return
3295
3296	class ExportJobContainerDownload(ExportCSVView):
3297	"""Page that downloads a students export csv file.
3298
3299	"""
3300	grok.context(VirtualExportJobContainer)
3301	grok.require('waeup.showStudents')
3302
3303	class DatacenterExportJobContainerJobConfig(ExportJobContainerJobConfig):
3304	"""Page that configures a students export job in datacenter.
3305
3306	"""
3307	grok.context(IDataCenter)
3308	redirect_target = '@@export'
3309
3310	class DatacenterExportJobContainerSelectStudents(ExportJobContainerJobConfig):
3311	"""Page that configures a students export job in datacenter.
3312
3313	"""
3314	grok.name('exportselected')
3315	grok.context(IDataCenter)
3316	redirect_target = '@@export'
3317	grok.template('exportselected')
3318	label = _('Configure student data export')
3319
3320	def update(self, START=None, students=None, exporter=None):
3321	self._set_exporter_values()
3322	if START is None:
3323	return
3324	utils = queryUtility(IKofaUtils)
3325	if not utils.expensive_actions_allowed():
3326	self.flash(_(
3327	"Currently, exporters cannot be started due to high "
3328	"system load. Please try again later."), type='danger')
3329	return
3330	try:
3331	ids = students.replace(',', ' ').split()
3332	except:
3333	self.flash(sys.exc_info()[1])
3334	self.redirect(self.url(self.redirect_target))
3335	return
3336	job_id = self.context.start_export_job(
3337	exporter, self.request.principal.id, selected=ids)
3338	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3339	self.context.logger.info(
3340	'%s - selected students exported: %s, job_id=%s' %
3341	(ob_class, exporter, job_id))
3342	self.flash(_('Export of selected students started.'))
3343	self.redirect(self.url(self.redirect_target))
3344	return
3345
3346	class FacultiesExportJobContainerJobConfig(ExportJobContainerJobConfig):
3347	"""Page that configures a students export job in facultiescontainer.
3348
3349	"""
3350	grok.context(VirtualFacultiesExportJobContainer)
3351
3352
3353	class FacultyExportJobContainerJobConfig(ExportJobContainerJobConfig):
3354	"""Page that configures a students export job in faculties.
3355
3356	"""
3357	grok.context(VirtualFacultyExportJobContainer)
3358
3359	@property
3360	def faccode(self):
3361	return self.context.__parent__.code
3362
3363	class DepartmentExportJobContainerJobConfig(ExportJobContainerJobConfig):
3364	"""Page that configures a students export job in departments.
3365
3366	"""
3367	grok.context(VirtualDepartmentExportJobContainer)
3368
3369	@property
3370	def depcode(self):
3371	return self.context.__parent__.code
3372
3373	class CertificateExportJobContainerJobConfig(ExportJobContainerJobConfig):
3374	"""Page that configures a students export job for certificates.
3375
3376	"""
3377	grok.context(VirtualCertificateExportJobContainer)
3378	grok.template('exportconfig_certificate')
3379
3380	@property
3381	def certcode(self):
3382	return self.context.__parent__.code
3383
3384	class CourseExportJobContainerJobConfig(ExportJobContainerJobConfig):
3385	"""Page that configures a students export job for courses.
3386
3387	In contrast to department or certificate student data exports the
3388	coursetickets_catalog is searched here. Therefore the update
3389	method from the base class is customized.
3390	"""
3391	grok.context(VirtualCourseExportJobContainer)
3392	grok.template('exportconfig_course')
3393
3394	def _set_exporter_values(self):
3395	# We provide only two exporters.
3396	exporters = []
3397	for name in ('students', 'coursetickets'):
3398	util = getUtility(ICSVExporter, name=name)
3399	exporters.append((util.title, name),)
3400	self.exporters = exporters
3401
3402	def update(self, START=None, session=None, level=None, mode=None,
3403	exporter=None):
3404	self._set_session_values()
3405	self._set_level_values()
3406	self._set_mode_values()
3407	self._set_exporter_values()
3408	if START is None:
3409	return
3410	utils = queryUtility(IKofaUtils)
3411	if not utils.expensive_actions_allowed():
3412	self.flash(_(
3413	"Currently, exporters cannot be started due to high "
3414	"system load. Please try again later."), type='danger')
3415	return
3416	if session == 'all':
3417	session = None
3418	if level == 'all':
3419	level = None
3420	job_id = self.context.start_export_job(exporter,
3421	self.request.principal.id,
3422	# Use a different catalog and
3423	# pass different keywords than
3424	# for the (default) students_catalog
3425	catalog='coursetickets',
3426	session=session,
3427	level=level,
3428	code=self.context.__parent__.code)
3429	ob_class = self.__implemented__.__name__.replace('waeup.kofa.','')
3430	self.context.logger.info(
3431	'%s - exported: %s (%s, %s, %s), job_id=%s'
3432	% (ob_class, exporter, session, level,
3433	self.context.__parent__.code, job_id))
3434	self.flash(_('Export started for course tickets with') +
3435	' level_session=%s, level=%s' % (
3436	session, level))
3437	self.redirect(self.url(self.redirect_target))
3438	return

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

Download in other formats: