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

Last change on this file since 13621 was 13610, checked in by Henrik Bettermann, 9 years ago

Add button and view which allow students to unregister their
current course list unless the courses have not been validated.

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