source: main/waeup.sirp/trunk/src/waeup/sirp/students/browser.py @ 7401

## $Id: browser.py 7386 2011-12-18 18:16:08Z henrik $
##
## Copyright (C) 2011 Uli Fouquet & Henrik Bettermann
## This program is free software; you can redistribute it and/or modify
## it under the terms of the GNU General Public License as published by
## the Free Software Foundation; either version 2 of the License, or
## (at your option) any later version.
##
## This program is distributed in the hope that it will be useful,
## but WITHOUT ANY WARRANTY; without even the implied warranty of
## MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
## GNU General Public License for more details.
##
## You should have received a copy of the GNU General Public License
## along with this program; if not, write to the Free Software
## Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
##
"""UI components for students and related components.
"""
import sys
import grok
from urllib import urlencode
from time import time
from datetime import datetime
from zope.event import notify
from zope.catalog.interfaces import ICatalog
from zope.component import queryUtility, getUtility, createObject
from zope.formlib.textwidgets import BytesDisplayWidget
#from hurry.query import Eq
#from hurry.query.query import Query
from hurry.workflow.interfaces import IWorkflowInfo, IWorkflowState
from waeup.sirp.accesscodes import (
    invalidate_accesscode, get_access_code, create_accesscode)
from waeup.sirp.accesscodes.workflow import USED
from waeup.sirp.browser import (
    SIRPPage, SIRPEditFormPage, SIRPAddFormPage, SIRPDisplayFormPage,
    ContactAdminForm, SIRPForm)
from waeup.sirp.browser.interfaces import ICaptchaManager
from waeup.sirp.browser.breadcrumbs import Breadcrumb
from waeup.sirp.browser.resources import datepicker, datatable, tabs, warning
from waeup.sirp.browser.viewlets import (
    ManageActionButton, AddActionButton)
from waeup.sirp.browser.layout import jsaction, JSAction
from waeup.sirp.interfaces import (
    ISIRPObject, IUserAccount, IExtFileStore, IPasswordValidator, IContactForm,
    ISIRPUtils, IUniversity)
from waeup.sirp.widgets.datewidget import (
    FriendlyDateWidget, FriendlyDateDisplayWidget,
    FriendlyDatetimeDisplayWidget)
from waeup.sirp.university.vocabularies import study_modes
from waeup.sirp.students.interfaces import (
    IStudentsContainer, IStudent, IStudentClearance,
    IStudentPersonal, IStudentBase, IStudentStudyCourse,
    IStudentAccommodation, IStudentClearanceEdit, IStudentStudyLevel,
    ICourseTicket, ICourseTicketAdd, IStudentPaymentsContainer,
    IStudentOnlinePayment, IBedTicket, IStudentsUtils, IStudentChangePassword
    )
from waeup.sirp.students.catalog import search
from waeup.sirp.students.workflow import (
    CLEARANCE, REQUESTED, RETURNING, CLEARED, REGISTERED, VALIDATED)
from waeup.sirp.students.studylevel import StudentStudyLevel, CourseTicket
from waeup.sirp.students.vocabularies import StudyLevelSource
from waeup.sirp.browser.resources import toggleall
from waeup.sirp.applicants.interfaces import IApplicantBaseData
from waeup.sirp.hostels.hostel import NOT_OCCUPIED

def write_log_message(view, message):
    ob_class = view.__implemented__.__name__.replace('waeup.sirp.','')
    view.context.getStudent().loggerInfo(ob_class, message)
    return

# Save function used for save methods in pages
def msave(view, **data):
    changed_fields = view.applyData(view.context, **data)
    # Turn list of lists into single list
    if changed_fields:
        changed_fields = reduce(lambda x,y: x+y, changed_fields.values())
    # Inform catalog if certificate has changed
    # (applyData does this only for the context)
    if 'certificate' in changed_fields:
        notify(grok.ObjectModifiedEvent(view.context.getStudent()))
    fields_string = ' + '.join(changed_fields)
    view.flash('Form has been saved.')
    if fields_string:
        write_log_message(view, 'saved: %s' % fields_string)
    return

def emit_lock_message(view):
    view.flash('The requested form is locked (read-only).')
    view.redirect(view.url(view.context))
    return

class StudentsBreadcrumb(Breadcrumb):
    """A breadcrumb for the students container.
    """
    grok.context(IStudentsContainer)
    title = 'Students'

class StudentBreadcrumb(Breadcrumb):
    """A breadcrumb for the student container.
    """
    grok.context(IStudent)

    def title(self):
        return self.context.display_fullname

class SudyCourseBreadcrumb(Breadcrumb):
    """A breadcrumb for the student study course.
    """
    grok.context(IStudentStudyCourse)
    title = 'Study Course'

class PaymentsBreadcrumb(Breadcrumb):
    """A breadcrumb for the student payments folder.
    """
    grok.context(IStudentPaymentsContainer)
    title = 'Payments'

class OnlinePaymentBreadcrumb(Breadcrumb):
    """A breadcrumb for payments.
    """
    grok.context(IStudentOnlinePayment)

    @property
    def title(self):
        return self.context.p_id

class AccommodationBreadcrumb(Breadcrumb):
    """A breadcrumb for the student accommodation folder.
    """
    grok.context(IStudentAccommodation)
    title = 'Accommodation'

    #@property
    #def target(self):
    #    prm = get_principal_role_manager()
    #    principal = get_current_principal()
    #    roles = [x[0] for x in prm.getRolesForPrincipal(principal.id)]
    #    if 'waeup.Student' in roles:
    #        return 'index'
    #    else:
    #        return 'manage'

class BedTicketBreadcrumb(Breadcrumb):
    """A breadcrumb for bed tickets.
    """
    grok.context(IBedTicket)

    @property
    def title(self):
        return 'Bed Ticket %s' % self.context.getSessionString()

class StudyLevelBreadcrumb(Breadcrumb):
    """A breadcrumb for course lists.
    """
    grok.context(IStudentStudyLevel)

    @property
    def title(self):
        return self.context.level_title

class StudentsContainerPage(SIRPPage):
    """The standard view for student containers.
    """
    grok.context(IStudentsContainer)
    grok.name('index')
    grok.require('waeup.viewStudentsContainer')
    grok.template('containerpage')
    label = 'Student Section'
    title = 'Students'
    pnav = 4

    def update(self, *args, **kw):
        datatable.need()
        form = self.request.form
        self.hitlist = []
        if 'searchterm' in form and form['searchterm']:
            self.searchterm = form['searchterm']
            self.searchtype = form['searchtype']
        elif 'old_searchterm' in form:
            self.searchterm = form['old_searchterm']
            self.searchtype = form['old_searchtype']
        else:
            if 'search' in form:
                self.flash('Empty search string.')
            return
        if self.searchtype == 'current_session':
            self.searchterm = int(self.searchterm)
        self.hitlist = search(query=self.searchterm,
            searchtype=self.searchtype, view=self)
        if not self.hitlist:
            self.flash('No student found.')
        return

class SetPasswordPage(SIRPPage):
    grok.context(ISIRPObject)
    grok.name('setpassword')
    grok.require('waeup.Anonymous')
    grok.template('setpassword')
    title = ''
    label = 'Set password for first-time login'
    ac_prefix = 'PWD'
    pnav = 0

    def update(self, SUBMIT=None):
        self.reg_number = self.request.form.get('reg_number', None)
        self.ac_series = self.request.form.get('ac_series', None)
        self.ac_number = self.request.form.get('ac_number', None)

        if SUBMIT is None:
            return
        hitlist = search(query=self.reg_number,
            searchtype='reg_number', view=self)
        if not hitlist:
            self.flash('No student found.')
            return
        if len(hitlist) != 1:   # Cannot happen but anyway
            self.flash('More than one student found.')
            return
        student = hitlist[0].context
        self.student_id = student.student_id
        student_pw = student.password
        pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
        code = get_access_code(pin)
        if not code:
            self.flash('Access code is invalid.')
            return
        if student_pw and pin == student.adm_code:
            self.flash('Password has already been set. Your Student Id is %s'
                % self.student_id)
            return
        elif student_pw:
            self.flash('Password has already been set. You are using the wrong Access Code.')
            return
        # Mark pin as used (this also fires a pin related transition)
        # and set student password
        if code.state == USED:
            self.flash('Access code has already been used.')
            return
        else:
            comment = u"AC invalidated for %s" % self.student_id
            # Here we know that the ac is in state initialized so we do not
            # expect an exception
            #import pdb; pdb.set_trace()
            invalidate_accesscode(pin,comment)
            IUserAccount(student).setPassword(self.ac_number)
            student.adm_code = pin
        self.flash('Password has been set. Your Student Id is %s'
            % self.student_id)
        return

class StudentsContainerManageActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudentsContainer)
    grok.view(StudentsContainerPage)
    grok.require('waeup.manageStudent')
    text = 'Manage student section'


class StudentsContainerManagePage(SIRPPage):
    """The manage page for student containers.
    """
    grok.context(IStudentsContainer)
    grok.name('manage')
    grok.require('waeup.manageStudent')
    grok.template('containermanagepage')
    pnav = 4
    title = 'Manage student section'

    @property
    def label(self):
        return self.title

    def update(self, *args, **kw):
        datatable.need()
        toggleall.need()
        warning.need()
        form = self.request.form
        self.hitlist = []
        if 'searchterm' in form and form['searchterm']:
            self.searchterm = form['searchterm']
            self.searchtype = form['searchtype']
        elif 'old_searchterm' in form:
            self.searchterm = form['old_searchterm']
            self.searchtype = form['old_searchtype']
        else:
            if 'search' in form:
                self.flash('Empty search string.')
            return
        if not 'entries' in form:
            self.hitlist = search(query=self.searchterm,
                searchtype=self.searchtype, view=self)
            if not self.hitlist:
                self.flash('No student found.')
            return
        entries = form['entries']
        if isinstance(entries, basestring):
            entries = [entries]
        deleted = []
        for entry in entries:
            if 'remove' in form:
                del self.context[entry]
                deleted.append(entry)
        self.hitlist = search(query=self.searchterm,
            searchtype=self.searchtype, view=self)
        if len(deleted):
            self.flash('Successfully removed: %s' % ', '.join(deleted))
        return

class StudentsContainerAddActionButton(AddActionButton):
    grok.order(1)
    grok.context(IStudentsContainer)
    grok.view(StudentsContainerManagePage)
    grok.require('waeup.manageStudent')
    text = 'Add student'
    target = 'addstudent'

class StudentAddFormPage(SIRPAddFormPage):
    """Add-form to add a student.
    """
    grok.context(IStudentsContainer)
    grok.require('waeup.manageStudent')
    grok.name('addstudent')
    form_fields = grok.AutoFields(IStudent).select(
        'firstname', 'middlename', 'lastname')
    title = 'Students'
    label = 'Add student'
    pnav = 4

    @grok.action('Create student record')
    def addStudent(self, **data):
        student = createObject(u'waeup.Student')
        self.applyData(student, **data)
        self.context.addStudent(student)
        self.flash('Student record created.')
        self.redirect(self.url(self.context[student.student_id], 'index'))
        return

class StudentBaseDisplayFormPage(SIRPDisplayFormPage):
    """ Page to display student base data
    """
    grok.context(IStudent)
    grok.name('index')
    grok.require('waeup.viewStudent')
    grok.template('basepage')
    form_fields = grok.AutoFields(IStudentBase).omit('password')
    pnav = 4
    title = 'Base Data'

    @property
    def label(self):
        return '%s: Base Data' % self.context.display_fullname

    @property
    def hasPassword(self):
        if self.context.password:
            return 'set'
        return 'unset'

class ContactActionButton(ManageActionButton):
    grok.order(4)
    grok.context(IStudent)
    grok.view(StudentBaseDisplayFormPage)
    grok.require('waeup.manageStudent')
    icon = 'actionicon_mail.png'
    text = 'Send email'
    target = 'contactstudent'

class ContactStudentForm(ContactAdminForm):
    grok.context(IStudent)
    grok.name('contactstudent')
    grok.require('waeup.viewStudent')
    pnav = 4
    title = 'Contact'
    form_fields = grok.AutoFields(IContactForm).select('subject', 'body')

    def update(self, subject=u''):
        self.form_fields.get('subject').field.default = subject
        self.subject = subject
        return

    def label(self):
        return u'Send message to %s' % self.context.display_fullname

    @grok.action('Send message now')
    def send(self, *args, **data):
        fullname = self.request.principal.title
        try:
            email_from = self.request.principal.email
        except AttributeError:
            email_from = self.config.email_admin
        username = self.request.principal.id
        usertype = self.request.principal.user_type.title()
        body = data['body']
        #subject = u'Mail from SIRP'
        subject = data['subject']
        email_to = self.context.email
        sirp_utils = getUtility(ISIRPUtils)
        success = sirp_utils.sendMail(fullname,username,usertype,self.config.name,
                  body,email_from,email_to,subject)
        if success:
            self.flash('Your message has been sent.')
        else:
            self.flash('An smtp server error occurred.')
        return

class StudentBaseManageActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudent)
    grok.view(StudentBaseDisplayFormPage)
    grok.require('waeup.manageStudent')
    text = 'Manage'
    target = 'manage_base'

class StudentBaseManageFormPage(SIRPEditFormPage):
    """ View to manage student base data
    """
    grok.context(IStudent)
    grok.name('manage_base')
    grok.require('waeup.manageStudent')
    form_fields = grok.AutoFields(IStudentBase).omit('student_id')
    grok.template('basemanagepage')
    label = 'Manage base data'
    title = 'Base Data'
    pnav = 4

    def update(self):
        datepicker.need() # Enable jQuery datepicker in date fields.
        tabs.need()
        super(StudentBaseManageFormPage, self).update()
        self.wf_info = IWorkflowInfo(self.context)
        return

    def getTransitions(self):
        """Return a list of dicts of allowed transition ids and titles.

        Each list entry provides keys ``name`` and ``title`` for
        internal name and (human readable) title of a single
        transition.
        """
        allowed_transitions = self.wf_info.getManualTransitions()
        return [dict(name='', title='No transition')] +[
            dict(name=x, title=y) for x, y in allowed_transitions]

    @grok.action('Save')
    def save(self, **data):
        form = self.request.form
        password = form.get('password', None)
        password_ctl = form.get('control_password', None)
        if password:
            validator = getUtility(IPasswordValidator)
            errors = validator.validate_password(password, password_ctl)
            if errors:
                self.flash( ' '.join(errors))
                return
        changed_fields = self.applyData(self.context, **data)
        # Turn list of lists into single list
        if changed_fields:
            changed_fields = reduce(lambda x,y: x+y, changed_fields.values())
        else:
            changed_fields = []
        if password:
            # Now we know that the form has no errors and can set password ...
            IUserAccount(self.context).setPassword(password)
            changed_fields.append('password')
        # ... and execute transition
        if form.has_key('transition') and form['transition']:
            transition_id = form['transition']
            self.wf_info.fireTransition(transition_id)
        fields_string = ' + '.join(changed_fields)
        self.flash('Form has been saved.')
        if fields_string:
            write_log_message(self, 'saved: % s' % fields_string)
        return

class StudentClearanceDisplayFormPage(SIRPDisplayFormPage):
    """ Page to display student clearance data
    """
    grok.context(IStudent)
    grok.name('view_clearance')
    grok.require('waeup.viewStudent')
    form_fields = grok.AutoFields(IStudentClearance).omit('clearance_locked')
    form_fields['date_of_birth'].custom_widget = FriendlyDateDisplayWidget('le')
    title = 'Clearance Data'
    pnav = 4

    @property
    def label(self):
        return '%s: Clearance Data' % self.context.display_fullname

class StudentClearanceManageActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudent)
    grok.view(StudentClearanceDisplayFormPage)
    grok.require('waeup.manageStudent')
    text = 'Manage'
    target = 'edit_clearance'

class StudentClearActionButton(ManageActionButton):
    grok.order(2)
    grok.context(IStudent)
    grok.view(StudentClearanceDisplayFormPage)
    grok.require('waeup.clearStudent')
    text = 'Clear student'
    target = 'clear'
    icon = 'actionicon_accept.png'

    @property
    def target_url(self):
        if self.context.state != REQUESTED:
            return ''
        return self.view.url(self.view.context, self.target)

class StudentRejectClearanceActionButton(ManageActionButton):
    grok.order(3)
    grok.context(IStudent)
    grok.view(StudentClearanceDisplayFormPage)
    grok.require('waeup.clearStudent')
    text = 'Reject clearance'
    target = 'reject_clearance'
    icon = 'actionicon_reject.png'

    @property
    def target_url(self):
        if self.context.state not in (REQUESTED, CLEARED):
            return ''
        return self.view.url(self.view.context, self.target)

class ClearanceSlipActionButton(ManageActionButton):
    grok.order(4)
    grok.context(IStudent)
    grok.view(StudentClearanceDisplayFormPage)
    grok.require('waeup.viewStudent')
    icon = 'actionicon_pdf.png'
    text = 'Download clearance slip'
    target = 'clearance.pdf'

class ExportPDFClearanceSlipPage(grok.View):
    """Deliver a PDF slip of the context.
    """
    grok.context(IStudent)
    grok.name('clearance.pdf')
    grok.require('waeup.viewStudent')
    form_fields = grok.AutoFields(IStudentClearance).omit('clearance_locked')
    form_fields['date_of_birth'].custom_widget = FriendlyDateDisplayWidget('le')
    prefix = 'form'
    title = 'Clearance Data'

    @property
    def label(self):
        return 'Clearance Slip of %s' % self.context.display_fullname

    def render(self):
        studentview = StudentBaseDisplayFormPage(self.context.getStudent(),
            self.request)
        students_utils = getUtility(IStudentsUtils)
        return students_utils.renderPDF(
            self, 'clearance.pdf',
            self.context.getStudent(), studentview)

class StudentClearanceManageFormPage(SIRPEditFormPage):
    """ Page to edit student clearance data
    """
    grok.context(IStudent)
    grok.name('edit_clearance')
    grok.require('waeup.manageStudent')
    grok.template('clearanceeditpage')
    form_fields = grok.AutoFields(IStudentClearance)
    label = 'Manage clearance data'
    title = 'Clearance Data'
    pnav = 4
    form_fields['date_of_birth'].custom_widget = FriendlyDateWidget('le-year')

    def update(self):
        datepicker.need() # Enable jQuery datepicker in date fields.
        tabs.need()
        return super(StudentClearanceManageFormPage, self).update()

    @grok.action('Save')
    def save(self, **data):
        msave(self, **data)
        return

class StudentClearPage(grok.View):
    """ Clear student by clearance officer
    """
    grok.context(IStudent)
    grok.name('clear')
    grok.require('waeup.clearStudent')

    def update(self):
        if self.context.state == REQUESTED:
            IWorkflowInfo(self.context).fireTransition('clear')
            self.flash('Student has been cleared.')
        else:
            self.flash('Student is in the wrong state.')
        self.redirect(self.url(self.context,'view_clearance'))
        return

    def render(self):
        return

class StudentRejectClearancePage(grok.View):
    """ Reject clearance by clearance officers
    """
    grok.context(IStudent)
    grok.name('reject_clearance')
    grok.require('waeup.clearStudent')

    def update(self):
        if self.context.state == CLEARED:
            IWorkflowInfo(self.context).fireTransition('reset4')
            message = 'Clearance has been annulled'
            self.flash(message)
        elif self.context.state == REQUESTED:
            IWorkflowInfo(self.context).fireTransition('reset3')
            message = 'Clearance request has been rejected'
            self.flash(message)
        else:
            self.flash('Student is in the wrong state.')
            self.redirect(self.url(self.context,'view_clearance'))
            return
        args = {'subject':message}
        self.redirect(self.url(self.context) +
            '/contactstudent?%s' % urlencode(args))
        return

    def render(self):
        return

class StudentPersonalDisplayFormPage(SIRPDisplayFormPage):
    """ Page to display student personal data
    """
    grok.context(IStudent)
    grok.name('view_personal')
    grok.require('waeup.viewStudent')
    form_fields = grok.AutoFields(IStudentPersonal)
    form_fields['perm_address'].custom_widget = BytesDisplayWidget
    title = 'Personal Data'
    pnav = 4

    @property
    def label(self):
        return '%s: Personal Data' % self.context.display_fullname

class StudentPersonalManageActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudent)
    grok.view(StudentPersonalDisplayFormPage)
    grok.require('waeup.manageStudent')
    text = 'Manage'
    target = 'edit_personal'

class StudentPersonalManageFormPage(SIRPEditFormPage):
    """ Page to edit student clearance data
    """
    grok.context(IStudent)
    grok.name('edit_personal')
    grok.require('waeup.viewStudent')
    form_fields = grok.AutoFields(IStudentPersonal)
    label = 'Manage personal data'
    title = 'Personal Data'
    pnav = 4

    @grok.action('Save')
    def save(self, **data):
        msave(self, **data)
        return

class StudyCourseDisplayFormPage(SIRPDisplayFormPage):
    """ Page to display the student study course data
    """
    grok.context(IStudentStudyCourse)
    grok.name('index')
    grok.require('waeup.viewStudent')
    form_fields = grok.AutoFields(IStudentStudyCourse)
    grok.template('studycoursepage')
    title = 'Study Course'
    pnav = 4

    @property
    def label(self):
        return '%s: Study Course' % self.context.__parent__.display_fullname

    @property
    def current_mode(self):
        if self.context.certificate:
            current_mode = study_modes.getTermByToken(
                self.context.certificate.study_mode).title
            return current_mode
        return
        
    @property
    def department(self):
        if self.context.certificate is not None:
            return self.context.certificate.__parent__.__parent__
        return

    @property
    def faculty(self):
        if self.context.certificate is not None:
            return self.context.certificate.__parent__.__parent__.__parent__
        return

class StudyCourseManageActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudentStudyCourse)
    grok.view(StudyCourseDisplayFormPage)
    grok.require('waeup.manageStudent')
    text = 'Manage'
    target = 'manage'

class StudyCourseManageFormPage(SIRPEditFormPage):
    """ Page to edit the student study course data
    """
    grok.context(IStudentStudyCourse)
    grok.name('manage')
    grok.require('waeup.manageStudent')
    grok.template('studycoursemanagepage')
    form_fields = grok.AutoFields(IStudentStudyCourse)
    title = 'Study Course'
    label = 'Manage study course'
    pnav = 4
    taboneactions = ['Save','Cancel']
    tabtwoactions = ['Remove selected levels','Cancel']
    tabthreeactions = ['Add study level']

    def update(self):
        super(StudyCourseManageFormPage, self).update()
        tabs.need()
        warning.need()
        datatable.need()
        return 

    @grok.action('Save')
    def save(self, **data):
        msave(self, **data)
        return

    @property
    def level_dict(self):
        studylevelsource = StudyLevelSource().factory
        for code in studylevelsource.getValues(self.context):
            title = studylevelsource.getTitle(self.context, code)
            yield(dict(code=code, title=title))

    @grok.action('Add study level')
    def addStudyLevel(self, **data):
        level_code = self.request.form.get('addlevel', None)
        studylevel = StudentStudyLevel()
        studylevel.level = int(level_code)
        try:
            self.context.addStudentStudyLevel(
                self.context.certificate,studylevel)
        except KeyError:
            self.flash('This level exists.')
        self.redirect(self.url(self.context, u'@@manage')+'#tab-2')
        return

    @jsaction('Remove selected levels')
    def delStudyLevels(self, **data):
        form = self.request.form
        if form.has_key('val_id'):
            child_id = form['val_id']
        else:
            self.flash('No study level selected.')
            self.redirect(self.url(self.context, '@@manage')+'#tab-2')
            return
        if not isinstance(child_id, list):
            child_id = [child_id]
        deleted = []
        for id in child_id:
            try:
                del self.context[id]
                deleted.append(id)
            except:
                self.flash('Could not delete %s: %s: %s' % (
                        id, sys.exc_info()[0], sys.exc_info()[1]))
        if len(deleted):
            self.flash('Successfully removed: %s' % ', '.join(deleted))
        self.redirect(self.url(self.context, u'@@manage')+'#tab-2')
        return

class StudyLevelDisplayFormPage(SIRPDisplayFormPage):
    """ Page to display student study levels
    """
    grok.context(IStudentStudyLevel)
    grok.name('index')
    grok.require('waeup.viewStudent')
    form_fields = grok.AutoFields(IStudentStudyLevel)
    grok.template('studylevelpage')
    pnav = 4

    def update(self):
        super(StudyLevelDisplayFormPage, self).update()
        datatable.need()
        return

    @property
    def title(self):
        return 'Study Level %s' % self.context.level_title

    @property
    def label(self):
        return '%s: Study Level %s' % (
            self.context.getStudent().display_fullname,self.context.level_title)

    @property
    def total_credits(self):
        total_credits = 0
        for key, val in self.context.items():
            total_credits += val.credits
        return total_credits

class CourseRegistrationSlipActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudentStudyLevel)
    grok.view(StudyLevelDisplayFormPage)
    grok.require('waeup.viewStudent')
    icon = 'actionicon_pdf.png'
    text = 'Download course registration slip'
    target = 'course_registration.pdf'

class ExportPDFCourseRegistrationSlipPage(grok.View):
    """Deliver a PDF slip of the context.
    """
    grok.context(IStudentStudyLevel)
    grok.name('course_registration.pdf')
    grok.require('waeup.viewStudent')
    form_fields = grok.AutoFields(IStudentStudyLevel)
    prefix = 'form'
    title = 'Level Data'
    content_title = 'Course List'

    @property
    def label(self):
        return 'Course Registration Slip %s' % self.context.level_title

    def render(self):
        studentview = StudentBaseDisplayFormPage(self.context.getStudent(),
            self.request)
        students_utils = getUtility(IStudentsUtils)
        tabledata = sorted(self.context.values(),
            key=lambda value: str(value.semester) + value.code)
        return students_utils.renderPDF(
            self, 'course_registration.pdf',
            self.context.getStudent(), studentview,
            tableheader=[('Sem.','semester', 1.5),('Code','code', 2.5),
                         ('Title','title', 5),
                         ('Dept.','dcode', 1.5), ('Faculty','fcode', 1.5),
                         ('Cred.', 'credits', 1.5),
                         ('Mand.', 'core_or_elective', 1.5),
                         ('Score', 'score', 1.5),('Auto', 'automatic', 1.5)
                         ],
            tabledata=tabledata)

class StudyLevelManageActionButton(ManageActionButton):
    grok.order(2)
    grok.context(IStudentStudyLevel)
    grok.view(StudyLevelDisplayFormPage)
    grok.require('waeup.manageStudent')
    text = 'Manage'
    target = 'manage'

class StudentValidateCoursesActionButton(ManageActionButton):
    grok.order(3)
    grok.context(IStudentStudyLevel)
    grok.view(StudyLevelDisplayFormPage)
    grok.require('waeup.validateStudent')
    text = 'Validate courses'
    target = 'validate_courses'
    icon = 'actionicon_accept.png'

    @property
    def target_url(self):
        if self.context.getStudent().state != REGISTERED or \
            str(self.context.__parent__.current_level) != self.context.__name__:
            return ''
        return self.view.url(self.view.context, self.target)

class StudentRejectCoursesActionButton(ManageActionButton):
    grok.order(4)
    grok.context(IStudentStudyLevel)
    grok.view(StudyLevelDisplayFormPage)
    grok.require('waeup.validateStudent')
    text = 'Reject courses'
    target = 'reject_courses'
    icon = 'actionicon_reject.png'

    @property
    def target_url(self):
        if self.context.getStudent().state not in (VALIDATED, REGISTERED) or \
            str(self.context.__parent__.current_level) != self.context.__name__:
            return ''
        return self.view.url(self.view.context, self.target)

class StudyLevelManageFormPage(SIRPEditFormPage):
    """ Page to edit the student study level data
    """
    grok.context(IStudentStudyLevel)
    grok.name('manage')
    grok.require('waeup.manageStudent')
    grok.template('studylevelmanagepage')
    form_fields = grok.AutoFields(IStudentStudyLevel)
    pnav = 4
    taboneactions = ['Save','Cancel']
    tabtwoactions = ['Add course ticket','Remove selected tickets','Cancel']

    def update(self):
        super(StudyLevelManageFormPage, self).update()
        tabs.need()
        warning.need()
        datatable.need()
        return

    @property
    def title(self):
        return 'Study Level %s' % self.context.level_title

    @property
    def label(self):
        return 'Manage study level %s' % self.context.level_title

    @grok.action('Save')
    def save(self, **data):
        msave(self, **data)
        return

    @grok.action('Add course ticket')
    def addCourseTicket(self, **data):
        self.redirect(self.url(self.context, '@@add'))

    @jsaction('Remove selected tickets')
    def delCourseTicket(self, **data):
        form = self.request.form
        if form.has_key('val_id'):
            child_id = form['val_id']
        else:
            self.flash('No ticket selected.')
            self.redirect(self.url(self.context, '@@manage')+'#tab-2')
            return
        if not isinstance(child_id, list):
            child_id = [child_id]
        deleted = []
        for id in child_id:
            try:
                del self.context[id]
                deleted.append(id)
            except:
                self.flash('Could not delete %s: %s: %s' % (
                        id, sys.exc_info()[0], sys.exc_info()[1]))
        if len(deleted):
            self.flash('Successfully removed: %s' % ', '.join(deleted))
        self.redirect(self.url(self.context, u'@@manage')+'#tab-2')
        return

class ValidateCoursesPage(grok.View):
    """ Validate course list by course adviser
    """
    grok.context(IStudentStudyLevel)
    grok.name('validate_courses')
    grok.require('waeup.validateStudent')

    def update(self):
        if str(self.context.__parent__.current_level) != self.context.__name__:
            self.flash('This level does not correspond current level.')
        elif self.context.getStudent().state == REGISTERED:
            IWorkflowInfo(self.context.getStudent()).fireTransition('validate_courses')
            self.flash('Course list has been validated.')
        else:
            self.flash('Student is in the wrong state.')
        self.redirect(self.url(self.context))
        return

    def render(self):
        return

class RejectCoursesPage(grok.View):
    """ Reject course list by course adviser
    """
    grok.context(IStudentStudyLevel)
    grok.name('reject_courses')
    grok.require('waeup.validateStudent')

    def update(self):
        if str(self.context.__parent__.current_level) != self.context.__name__:
            self.flash('This level does not correspond current level.')
            self.redirect(self.url(self.context))
            return
        elif self.context.getStudent().state == VALIDATED:
            IWorkflowInfo(self.context.getStudent()).fireTransition('reset8')
            message = 'Course list request has been annulled'
            self.flash(message)
        elif self.context.getStudent().state == REGISTERED:
            IWorkflowInfo(self.context.getStudent()).fireTransition('reset7')
            message = 'Course list request has been rejected'
            self.flash(message)
        else:
            self.flash('Student is in the wrong state.')
            self.redirect(self.url(self.context))
            return
        args = {'subject':message}
        self.redirect(self.url(self.context.getStudent()) +
            '/contactstudent?%s' % urlencode(args))
        return

    def render(self):
        return

class CourseTicketAddFormPage(SIRPAddFormPage):
    """Add a course ticket.
    """
    grok.context(IStudentStudyLevel)
    grok.name('add')
    grok.require('waeup.manageStudent')
    label = 'Add course ticket'
    form_fields = grok.AutoFields(ICourseTicketAdd).omit(
        'grade', 'score', 'automatic')
    pnav = 4

    @property
    def title(self):
        return 'Study Level %s' % self.context.level_title

    @grok.action('Add course ticket')
    def addCourseTicket(self, **data):
        ticket = CourseTicket()
        course = data['course']
        ticket.core_or_elective = data['core_or_elective']
        ticket.automatic = False
        ticket.code = course.code
        ticket.title = course.title
        ticket.faculty = course.__parent__.__parent__.__parent__.title
        ticket.department = course.__parent__.__parent__.title
        ticket.fcode = course.__parent__.__parent__.__parent__.code
        ticket.dcode = course.__parent__.__parent__.code
        ticket.credits = course.credits
        ticket.passmark = course.passmark
        ticket.semester = course.semester
        try:
            self.context.addCourseTicket(ticket)
        except KeyError:
            self.flash('The ticket exists.')
            return
        self.flash('Successfully added %s.' % ticket.code)
        self.redirect(self.url(self.context, u'@@manage')+'#tab-2')
        return

    @grok.action('Cancel')
    def cancel(self, **data):
        self.redirect(self.url(self.context))

class CourseTicketDisplayFormPage(SIRPDisplayFormPage):
    """ Page to display course tickets
    """
    grok.context(ICourseTicket)
    grok.name('index')
    grok.require('waeup.viewStudent')
    form_fields = grok.AutoFields(ICourseTicket)
    grok.template('courseticketpage')
    pnav = 4

    @property
    def title(self):
        return 'Course Ticket %s' % self.context.code

    @property
    def label(self):
        return '%s: Course Ticket %s' % (
            self.context.getStudent().display_fullname,self.context.code)

class CourseTicketManageActionButton(ManageActionButton):
    grok.order(1)
    grok.context(ICourseTicket)
    grok.view(CourseTicketDisplayFormPage)
    grok.require('waeup.manageStudent')
    text = 'Manage'
    target = 'manage'

class CourseTicketManageFormPage(SIRPEditFormPage):
    """ Page to manage course tickets
    """
    grok.context(ICourseTicket)
    grok.name('manage')
    grok.require('waeup.manageStudent')
    form_fields = grok.AutoFields(ICourseTicket)
    grok.template('courseticketmanagepage')
    pnav = 4

    @property
    def title(self):
        return 'Course Ticket %s' % self.context.code

    @property
    def label(self):
        return 'Manage course ticket %s' % self.context.code

    @grok.action('Save')
    def save(self, **data):
        msave(self, **data)
        return

# We don't need the display form page yet
#class PaymentsDisplayFormPage(SIRPDisplayFormPage):
#    """ Page to display the student payments
#    """
#    grok.context(IStudentPaymentsContainer)
#    grok.name('view')
#    grok.require('waeup.viewStudent')
#    form_fields = grok.AutoFields(IStudentPaymentsContainer)
#    grok.template('paymentspage')
#    title = 'Payments'
#    pnav = 4

#    @property
#    def label(self):
#        return '%s: Payments' % self.context.__parent__.display_fullname

#    def update(self):
#        super(PaymentsDisplayFormPage, self).update()
#        datatable.need()
#        return

# This manage form page is for both students and students officers.
class PaymentsManageFormPage(SIRPEditFormPage):
    """ Page to manage the student payments
    """
    grok.context(IStudentPaymentsContainer)
    grok.name('index')
    grok.require('waeup.payStudent')
    form_fields = grok.AutoFields(IStudentPaymentsContainer)
    grok.template('paymentsmanagepage')
    title = 'Payments'
    pnav = 4

    def unremovable(self, ticket):
        usertype = getattr(self.request.principal, 'user_type', None)
        if not usertype:
            return False
        return (self.request.principal.user_type == 'student' and ticket.r_code)

    @property
    def label(self):
        return '%s: Payments' % self.context.__parent__.display_fullname

    def update(self):
        super(PaymentsManageFormPage, self).update()
        datatable.need()
        warning.need()
        return

    @jsaction('Remove selected tickets')
    def delPaymentTicket(self, **data):
        form = self.request.form
        if form.has_key('val_id'):
            child_id = form['val_id']
        else:
            self.flash('No payment selected.')
            self.redirect(self.url(self.context))
            return
        if not isinstance(child_id, list):
            child_id = [child_id]
        deleted = []
        for id in child_id:
            # Students are not allowed to remove used payment tickets
            if not self.unremovable(self.context[id]):
                try:
                    del self.context[id]
                    deleted.append(id)
                except:
                    self.flash('Could not delete %s: %s: %s' % (
                            id, sys.exc_info()[0], sys.exc_info()[1]))
        if len(deleted):
            self.flash('Successfully removed: %s' % ', '.join(deleted))
            write_log_message(self,'removed: % s' % ', '.join(deleted))
        self.redirect(self.url(self.context))
        return

    @grok.action('Add online payment ticket')
    def addPaymentTicket(self, **data):
        self.redirect(self.url(self.context, '@@addop'))

#class OnlinePaymentManageActionButton(ManageActionButton):
#    grok.order(1)
#    grok.context(IStudentPaymentsContainer)
#    grok.view(PaymentsDisplayFormPage)
#    grok.require('waeup.manageStudent')
#    text = 'Manage payments'
#    target = 'manage'

class OnlinePaymentAddFormPage(SIRPAddFormPage):
    """ Page to add an online payment ticket
    """
    grok.context(IStudentPaymentsContainer)
    grok.name('addop')
    grok.require('waeup.payStudent')
    form_fields = grok.AutoFields(IStudentOnlinePayment).select(
        'p_category')
    #zzgrok.template('addpaymentpage')
    label = 'Add online payment'
    title = 'Payments'
    pnav = 4
    
    @grok.action('Create ticket')
    def createTicket(self, **data):
        p_category = data['p_category']
        student = self.context.__parent__
        if p_category == 'bed_allocation' and student[
            'studycourse'].current_session != grok.getSite()[
            'configuration'].accommodation_session:
                self.flash(
                    'Your current session does not match accommodation session.')
                self.redirect(self.url(self.context))
                return
        students_utils = getUtility(IStudentsUtils)
        pay_details  = students_utils.getPaymentDetails(
            p_category,student)
        if pay_details['error']:
            self.flash(pay_details['error'])
            self.redirect(self.url(self.context))
            return
        p_item = pay_details['p_item']
        p_session = pay_details['p_session']
        for key in self.context.keys():
            ticket = self.context[key]
            if ticket.p_state == 'paid' and\
               ticket.p_category == p_category and \
               ticket.p_item == p_item and \
               ticket.p_session == p_session:
                  self.flash(
                      'This type of payment has already been made.')
                  self.redirect(self.url(self.context))
                  return
        payment = createObject(u'waeup.StudentOnlinePayment')
        self.applyData(payment, **data)
        timestamp = "%d" % int(time()*1000)
        #order_id = "%s%s" % (student_id[1:],timestamp)
        payment.p_id = "p%s" % timestamp
        payment.p_item = p_item
        payment.p_session = p_session
        payment.amount_auth = pay_details['amount']
        payment.surcharge_1 = pay_details['surcharge_1']
        payment.surcharge_2 = pay_details['surcharge_2']
        payment.surcharge_3 = pay_details['surcharge_3']
        self.context[payment.p_id] = payment
        self.flash('Payment ticket created.')
        self.redirect(self.url(self.context))
        return

class OnlinePaymentDisplayFormPage(SIRPDisplayFormPage):
    """ Page to view an online payment ticket
    """
    grok.context(IStudentOnlinePayment)
    grok.name('index')
    grok.require('waeup.viewStudent')
    form_fields = grok.AutoFields(IStudentOnlinePayment)
    form_fields['creation_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
    form_fields['payment_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
    pnav = 4

    @property
    def title(self):
        return 'Online Payment Ticket %s' % self.context.p_id

    @property
    def label(self):
        return '%s: Online Payment Ticket %s' % (
            self.context.getStudent().display_fullname,self.context.p_id)

class PaymentReceiptActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudentOnlinePayment)
    grok.view(OnlinePaymentDisplayFormPage)
    grok.require('waeup.viewStudent')
    icon = 'actionicon_pdf.png'
    text = 'Download payment receipt'
    target = 'payment_receipt.pdf'

    @property
    def target_url(self):
        if self.context.p_state != 'paid':
            return ''
        return self.view.url(self.view.context, self.target)

class RequestCallbackActionButton(ManageActionButton):
    grok.order(2)
    grok.context(IStudentOnlinePayment)
    grok.view(OnlinePaymentDisplayFormPage)
    grok.require('waeup.payStudent')
    icon = 'actionicon_call.png'
    text = 'Request callback'
    target = 'callback'

    @property
    def target_url(self):
        if self.context.p_state != 'unpaid':
            return ''
        return self.view.url(self.view.context, self.target)

class OnlinePaymentCallbackPage(grok.View):
    """ Callback view
    """
    grok.context(IStudentOnlinePayment)
    grok.name('callback')
    grok.require('waeup.payStudent')

    # This update method simulates a valid callback und must be
    # specified in the customization package. The parameters must be taken
    # from the incoming request.
    def update(self):
        if self.context.p_state == 'paid':
            self.flash('This ticket has already been paid.')
            return
        student = self.context.getStudent()
        write_log_message(self,'valid callback: %s' % self.context.p_id)
        self.context.r_amount_approved = self.context.amount_auth
        self.context.r_card_num = u'0000'
        self.context.r_code = u'00'
        self.context.p_state = 'paid'
        self.context.payment_date = datetime.now()
        if self.context.p_category == 'clearance':
            # Create CLR access code
            pin, error = create_accesscode('CLR',0,student.student_id)
            if error:
                self.flash('Valid callback received. ' + error)
                return
            self.context.ac = pin
        elif self.context.p_category == 'schoolfee':
            # Create SFE access code
            pin, error = create_accesscode('SFE',0,student.student_id)
            if error:
                self.flash('Valid callback received. ' + error)
                return
            self.context.ac = pin
        elif self.context.p_category == 'bed_allocation':
            # Create HOS access code
            pin, error = create_accesscode('HOS',0,student.student_id)
            if error:
                self.flash('Valid callback received. ' + error)
                return
            self.context.ac = pin
        self.flash('Valid callback received.')
        return

    def render(self):
        self.redirect(self.url(self.context, '@@index'))
        return

class ExportPDFPaymentSlipPage(grok.View):
    """Deliver a PDF slip of the context.
    """
    grok.context(IStudentOnlinePayment)
    grok.name('payment_receipt.pdf')
    grok.require('waeup.viewStudent')
    form_fields = grok.AutoFields(IStudentOnlinePayment)
    form_fields['creation_date'].custom_widget = FriendlyDateDisplayWidget('le')
    form_fields['payment_date'].custom_widget = FriendlyDateDisplayWidget('le')
    prefix = 'form'
    title = 'Payment Data'

    @property
    def label(self):
        return 'Online Payment Receipt %s' % self.context.p_id

    def render(self):
        if self.context.p_state != 'paid':
            self.flash('Ticket not yet paid.')
            self.redirect(self.url(self.context))
            return
        studentview = StudentBaseDisplayFormPage(self.context.getStudent(),
            self.request)
        students_utils = getUtility(IStudentsUtils)
        return students_utils.renderPDF(self, 'payment_receipt.pdf',
            self.context.getStudent(), studentview)

# We don't need the display form page yet
#class AccommodationDisplayFormPage(SIRPDisplayFormPage):
#    """ Page to display the student accommodation data
#    """
#    grok.context(IStudentAccommodation)
#    grok.name('xxx')
#    grok.require('waeup.viewStudent')
#    form_fields = grok.AutoFields(IStudentAccommodation)
#    #grok.template('accommodationpage')
#    title = 'Accommodation'
#    pnav = 4

#    @property
#    def label(self):
#        return '%s: Accommodation Data' % self.context.__parent__.display_fullname

# This manage form page is for both students and students officers.
class AccommodationManageFormPage(SIRPEditFormPage):
    """ Page to manage bed tickets.
    """
    grok.context(IStudentAccommodation)
    grok.name('index')
    grok.require('waeup.handleAccommodation')
    form_fields = grok.AutoFields(IStudentAccommodation)
    grok.template('accommodationmanagepage')
    title = 'Accommodation'
    pnav = 4
    officers_only_actions = ['Remove selected']

    @property
    def label(self):
        return '%s: Accommodation' % self.context.__parent__.display_fullname

    def update(self):
        super(AccommodationManageFormPage, self).update()
        datatable.need()
        warning.need()
        return

    @jsaction('Remove selected')
    def delBedTickets(self, **data):
        if getattr(self.request.principal, 'user_type', None) == 'student':
            self.flash('You are not allowed to remove bed tickets.')
            self.redirect(self.url(self.context))
            return
        form = self.request.form
        if form.has_key('val_id'):
            child_id = form['val_id']
        else:
            self.flash('No bed ticket selected.')
            self.redirect(self.url(self.context))
            return
        if not isinstance(child_id, list):
            child_id = [child_id]
        deleted = []
        for id in child_id:
            del self.context[id]
            deleted.append(id)
        if len(deleted):
            self.flash('Successfully removed: %s' % ', '.join(deleted))
            write_log_message(self,'removed: % s' % ', '.join(deleted))
        self.redirect(self.url(self.context))
        return

    @property
    def selected_actions(self):
        sa = self.actions
        if getattr(self.request.principal, 'user_type', None) == 'student':
            sa = [action for action in self.actions
                  if not action.label in self.officers_only_actions]
        return sa

class AddBedTicketActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudentAccommodation)
    grok.view(AccommodationManageFormPage)
    grok.require('waeup.handleAccommodation')
    icon = 'actionicon_home.png'
    text = 'Book accommodation'
    target = 'add'

class BedTicketAddPage(SIRPPage):
    """ Page to add an online payment ticket
    """
    grok.context(IStudentAccommodation)
    grok.name('add')
    grok.require('waeup.handleAccommodation')
    grok.template('enterpin')
    ac_prefix = 'HOS'
    label = 'Add bed ticket'
    title = 'Add bed ticket'
    pnav = 4
    buttonname = 'Create bed ticket'
    notice = ''

    def update(self, SUBMIT=None):
        student = self.context.getStudent()
        students_utils = getUtility(IStudentsUtils)
        acc_details  = students_utils.getAccommodationDetails(student)
        if not acc_details:
            self.flash("Your data are incomplete.")
            self.redirect(self.url(self.context))
            return
        if not student.state in acc_details['allowed_states']:
            self.flash("You are in the wrong registration state.")
            self.redirect(self.url(self.context))
            return
        if student['studycourse'].current_session != acc_details['booking_session']:
            self.flash(
                'Your current session does not match accommodation session.')
            self.redirect(self.url(self.context))
            return
        if str(acc_details['booking_session']) in self.context.keys():
            self.flash('You already booked a bed space in current accommodation session.')
            self.redirect(self.url(self.context))
            return
        self.ac_series = self.request.form.get('ac_series', None)
        self.ac_number = self.request.form.get('ac_number', None)
        if SUBMIT is None:
            return
        pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
        code = get_access_code(pin)
        if not code:
            self.flash('Activation code is invalid.')
            return
        # Search and book bed
        cat = queryUtility(ICatalog, name='beds_catalog', default=None)
        entries = cat.searchResults(
            owner=(student.student_id,student.student_id))
        if len(entries):
            # If bed space has bee manually allocated use this bed
            bed = [entry for entry in entries][0]
        else:
            # else search for other available beds
            entries = cat.searchResults(
                bed_type=(acc_details['bt'],acc_details['bt']))
            available_beds = [
                entry for entry in entries if entry.owner == NOT_OCCUPIED]
            if available_beds:
                students_utils = getUtility(IStudentsUtils)
                bed = students_utils.selectBed(available_beds)
                bed.bookBed(student.student_id)
            else:
                self.flash('There is no free bed in your category %s.'
                            % acc_details['bt'])
                return
        # Mark pin as used (this also fires a pin related transition)
        if code.state == USED:
            self.flash('Activation code has already been used.')
            return
        else:
            comment = u"AC invalidated for %s" % self.context.getStudent().student_id
            # Here we know that the ac is in state initialized so we do not
            # expect an exception, but the owner might be different
            if not invalidate_accesscode(
                pin,comment,self.context.getStudent().student_id):
                self.flash('You are not the owner of this access code.')
                return
        # Create bed ticket
        bedticket = createObject(u'waeup.BedTicket')
        bedticket.booking_code = pin
        bedticket.booking_session = acc_details['booking_session']
        bedticket.bed_type = acc_details['bt']
        bedticket.bed = bed
        hall_title = bed.__parent__.hostel_name
        coordinates = bed.getBedCoordinates()[1:]
        block, room_nr, bed_nr = coordinates
        bedticket.bed_coordinates = '%s, Block %s, Room %s, Bed %s (%s)' % (
            hall_title, block, room_nr, bed_nr, bed.bed_type)
        key = str(acc_details['booking_session'])
        self.context[key] = bedticket
        self.flash('Bed ticket created and bed booked: %s'
            % bedticket.bed_coordinates)
        self.redirect(self.url(self.context))
        return

class BedTicketDisplayFormPage(SIRPDisplayFormPage):
    """ Page to display bed tickets
    """
    grok.context(IBedTicket)
    grok.name('index')
    grok.require('waeup.handleAccommodation')
    form_fields = grok.AutoFields(IBedTicket)
    form_fields[
        'booking_date'].custom_widget = FriendlyDatetimeDisplayWidget('le')
    pnav = 4

    @property
    def label(self):
        return 'Bed Ticket for Session %s' % self.context.getSessionString()

    @property
    def title(self):
        return 'Bed Ticket %s' % self.context.getSessionString()

class BedTicketSlipActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IBedTicket)
    grok.view(BedTicketDisplayFormPage)
    grok.require('waeup.handleAccommodation')
    icon = 'actionicon_pdf.png'
    text = 'Download bed allocation slip'
    target = 'bed_allocation.pdf'

class ExportPDFBedTicketSlipPage(grok.View):
    """Deliver a PDF slip of the context.
    """
    grok.context(IBedTicket)
    grok.name('bed_allocation.pdf')
    grok.require('waeup.handleAccommodation')
    form_fields = grok.AutoFields(IBedTicket)
    form_fields['booking_date'].custom_widget = FriendlyDateDisplayWidget('le')
    prefix = 'form'
    title = 'Bed Allocation Data'

    @property
    def label(self):
        return 'Bed Allocation: %s' % self.context.bed_coordinates

    def render(self):
        studentview = StudentBaseDisplayFormPage(self.context.getStudent(),
            self.request)
        students_utils = getUtility(IStudentsUtils)
        return students_utils.renderPDF(
            self, 'bed_allocation.pdf',
            self.context.getStudent(), studentview)

class RelocateStudentActionButton(ManageActionButton):
    grok.order(2)
    grok.context(IBedTicket)
    grok.view(BedTicketDisplayFormPage)
    grok.require('waeup.manageHostels')
    icon = 'actionicon_reload.png'
    text = 'Relocate student'
    target = 'relocate'

class BedTicketRelocationPage(grok.View):
    """ Callback view
    """
    grok.context(IBedTicket)
    grok.name('relocate')
    grok.require('waeup.manageHostels')

    # Relocate student if student parameters have changed or the bed_type
    # of the bed has changed
    def update(self):
        student = self.context.getStudent()
        students_utils = getUtility(IStudentsUtils)
        acc_details  = students_utils.getAccommodationDetails(student)
        if self.context.bed != None and \
              'reserved' in self.context.bed.bed_type:
            self.flash("Students in reserved beds can't be relocated.")
            self.redirect(self.url(self.context))
            return
        if acc_details['bt'] == self.context.bed_type and \
                self.context.bed != None and \
                self.context.bed.bed_type == self.context.bed_type:
            self.flash("Student can't be relocated.")
            self.redirect(self.url(self.context))
            return
        # Search a bed
        cat = queryUtility(ICatalog, name='beds_catalog', default=None)
        entries = cat.searchResults(
            owner=(student.student_id,student.student_id))
        if len(entries) and self.context.bed == None:
            # If booking has been cancelled but other bed space has been
            # manually allocated after cancellation use this bed
            new_bed = [entry for entry in entries][0]
        else:
            # Search for other available beds
            entries = cat.searchResults(
                bed_type=(acc_details['bt'],acc_details['bt']))
            available_beds = [
                entry for entry in entries if entry.owner == NOT_OCCUPIED]
            if available_beds:
                students_utils = getUtility(IStudentsUtils)
                new_bed = students_utils.selectBed(available_beds)
                new_bed.bookBed(student.student_id)
            else:
                self.flash('There is no free bed in your category %s.'
                            % acc_details['bt'])
                self.redirect(self.url(self.context))
                return
        # Rlease old bed if exists
        if self.context.bed != None:
            self.context.bed.owner = NOT_OCCUPIED
            notify(grok.ObjectModifiedEvent(self.context.bed))
        # Alocate new bed
        self.context.bed_type = acc_details['bt']
        self.context.bed = new_bed
        hall_title = new_bed.__parent__.hostel_name
        coordinates = new_bed.getBedCoordinates()[1:]
        block, room_nr, bed_nr = coordinates
        self.context.bed_coordinates = '%s, Block %s, Room %s, Bed %s (%s)' % (
            hall_title, block, room_nr, bed_nr, new_bed.bed_type)
        self.flash('Student relocated: %s' % self.context.bed_coordinates)
        self.redirect(self.url(self.context))
        return

    def render(self):
        #self.redirect(self.url(self.context, '@@index'))
        return

class StudentHistoryPage(SIRPPage):
    """ Page to display student clearance data
    """
    grok.context(IStudent)
    grok.name('history')
    grok.require('waeup.viewStudent')
    grok.template('studenthistory')
    title = 'History'
    pnav = 4

    @property
    def label(self):
        return '%s: History' % self.context.display_fullname

# Pages for students only

class StudentBaseActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudent)
    grok.view(StudentBaseDisplayFormPage)
    grok.require('waeup.handleStudent')
    text = 'Edit base data'
    target = 'edit_base'

class StudentPasswordActionButton(ManageActionButton):
    grok.order(2)
    grok.context(IStudent)
    grok.view(StudentBaseDisplayFormPage)
    grok.require('waeup.handleStudent')
    icon = 'actionicon_key.png'
    text = 'Change password'
    target = 'change_password'

class StudentPassportActionButton(ManageActionButton):
    grok.order(3)
    grok.context(IStudent)
    grok.view(StudentBaseDisplayFormPage)
    grok.require('waeup.handleStudent')
    icon = 'actionicon_portrait.png'
    text = 'Change portrait'
    target = 'change_portrait'

    @property
    def target_url(self):
        if self.context.state != 'admitted':
            return ''
        return self.view.url(self.view.context, self.target)

class StudentBaseEditFormPage(SIRPEditFormPage):
    """ View to edit student base data
    """
    grok.context(IStudent)
    grok.name('edit_base')
    grok.require('waeup.handleStudent')
    form_fields = grok.AutoFields(IStudentBase).select(
        'email', 'phone')
    label = 'Edit base data'
    title = 'Base Data'
    pnav = 4

    @grok.action('Save')
    def save(self, **data):
        msave(self, **data)
        return

class StudentChangePasswordPage(SIRPEditFormPage):
    """ View to manage student base data
    """
    grok.context(IStudent)
    grok.name('change_password')
    grok.require('waeup.handleStudent')
    grok.template('change_password')
    label = 'Change password'
    title = 'Base Data'
    pnav = 4

    @grok.action('Save')
    def save(self, **data):
        form = self.request.form
        password = form.get('change_password', None)
        password_ctl = form.get('change_password_repeat', None)
        if password:
            validator = getUtility(IPasswordValidator)
            errors = validator.validate_password(password, password_ctl)
            if not errors:
                IUserAccount(self.context).setPassword(password)
                write_log_message(self, 'saved: password')
                self.flash('Password changed.')
            else:
                self.flash( ' '.join(errors))
        return

class StudentFilesUploadPage(SIRPPage):
    """ View to upload files by student
    """
    grok.context(IStudent)
    grok.name('change_portrait')
    grok.require('waeup.uploadStudentFile')
    grok.template('filesuploadpage')
    label = 'Upload portrait'
    title = 'Base Data'
    pnav = 4

    def update(self):
        if self.context.getStudent().state != 'admitted':
            emit_lock_message(self)
            return
        super(StudentFilesUploadPage, self).update()
        return

class StudentClearanceStartActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudent)
    grok.view(StudentClearanceDisplayFormPage)
    grok.require('waeup.handleStudent')
    icon = 'actionicon_start.gif'
    text = 'Start clearance'
    target = 'start_clearance'

    @property
    def target_url(self):
        if self.context.state != 'admitted':
            return ''
        return self.view.url(self.view.context, self.target)

class StartClearancePage(SIRPPage):
    grok.context(IStudent)
    grok.name('start_clearance')
    grok.require('waeup.handleStudent')
    grok.template('enterpin')
    title = 'Start clearance'
    label = 'Start clearance'
    ac_prefix = 'CLR'
    notice = ''
    pnav = 4
    buttonname = 'Start clearance now'

    @property
    def all_required_fields_filled(self):
        if self.context.email and self.context.phone:
            return True
        return False

    @property
    def portrait_uploaded(self):
        store = getUtility(IExtFileStore)
        if store.getFileByContext(self.context, attr=u'passport.jpg'):
            return True
        return False

    def update(self, SUBMIT=None):
        if not self.context.state == 'admitted':
            self.flash("Wrong state.")
            self.redirect(self.url(self.context))
            return
        if not self.portrait_uploaded:
            self.flash("No portrait uploaded.")
            self.redirect(self.url(self.context, 'change_portrait'))
            return
        if not self.all_required_fields_filled:
            self.flash("Not all required fields filled.")
            self.redirect(self.url(self.context, 'edit_base'))
            return
        self.ac_series = self.request.form.get('ac_series', None)
        self.ac_number = self.request.form.get('ac_number', None)

        if SUBMIT is None:
            return
        pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
        code = get_access_code(pin)
        if not code:
            self.flash('Activation code is invalid.')
            return
        # Mark pin as used (this also fires a pin related transition)
        # and fire transition start_clearance
        if code.state == USED:
            self.flash('Activation code has already been used.')
            return
        else:
            comment = u"AC invalidated for %s" % self.context.student_id
            # Here we know that the ac is in state initialized so we do not
            # expect an exception, but the owner might be different
            if not invalidate_accesscode(pin,comment,self.context.student_id):
                self.flash('You are not the owner of this access code.')
                return
            self.context.clr_code = pin
        IWorkflowInfo(self.context).fireTransition('start_clearance')
        self.flash('Clearance process has been started.')
        self.redirect(self.url(self.context,'cedit'))
        return

class StudentClearanceEditActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudent)
    grok.view(StudentClearanceDisplayFormPage)
    grok.require('waeup.handleStudent')
    text = 'Edit'
    target = 'cedit'

    @property
    def target_url(self):
        if self.context.clearance_locked:
            return ''
        return self.view.url(self.view.context, self.target)

class StudentClearanceEditFormPage(StudentClearanceManageFormPage):
    """ View to edit student clearance data by student
    """
    grok.context(IStudent)
    grok.name('cedit')
    grok.require('waeup.handleStudent')
    form_fields = grok.AutoFields(
        IStudentClearanceEdit).omit('clearance_locked')
    label = 'Edit clearance data'
    title = 'Clearance Data'
    form_fields['date_of_birth'].custom_widget = FriendlyDateWidget('le-year')

    def update(self):
        if self.context.clearance_locked:
            emit_lock_message(self)
            return
        return super(StudentClearanceEditFormPage, self).update()

    @grok.action('Save')
    def save(self, **data):
        self.applyData(self.context, **data)
        self.flash('Clearance form has been saved.')
        return

    # To be specified in the customisation package
    def dataNotComplete(self):
        #store = getUtility(IExtFileStore)
        #if not store.getFileByContext(self.context, attr=u'xyz.jpg'):
        #    return 'No xyz scan uploaded.'
        return False

    @grok.action('Save and request clearance')
    def requestClearance(self, **data):
        self.applyData(self.context, **data)
        #self.context._p_changed = True
        if self.dataNotComplete():
            self.flash(self.dataNotComplete())
            return
        self.flash('Clearance form has been saved.')
        self.redirect(self.url(self.context,'request_clearance'))
        return

class RequestClearancePage(SIRPPage):
    grok.context(IStudent)
    grok.name('request_clearance')
    grok.require('waeup.handleStudent')
    grok.template('enterpin')
    title = 'Request clearance'
    label = 'Request clearance'
    notice = 'Enter the CLR access code used for starting clearance.'
    ac_prefix = 'CLR'
    pnav = 4
    buttonname = 'Request clearance now'

    def update(self, SUBMIT=None):
        self.ac_series = self.request.form.get('ac_series', None)
        self.ac_number = self.request.form.get('ac_number', None)
        if SUBMIT is None:
            return
        pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
        if self.context.clr_code != pin:
            self.flash("This isn't your CLR access code.")
            return
        state = IWorkflowState(self.context).getState()
        # This shouldn't happen, but the application officer
        # might have forgotten to lock the form after changing the state
        if state != CLEARANCE:
            self.flash('This form cannot be submitted. Wrong state!')
            return
        IWorkflowInfo(self.context).fireTransition('request_clearance')
        self.flash('Clearance has been requested.')
        self.redirect(self.url(self.context))
        return

class CourseRegistrationStartActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudentStudyCourse)
    grok.view(StudyCourseDisplayFormPage)
    grok.require('waeup.handleStudent')
    icon = 'actionicon_start.gif'
    text = 'Start course registration'
    target = 'start_course_registration'

    @property
    def target_url(self):
        if not self.context.getStudent().state in (CLEARED,RETURNING):
            return ''
        return self.view.url(self.view.context, self.target)

class StartCourseRegistrationPage(SIRPPage):
    grok.context(IStudentStudyCourse)
    grok.name('start_course_registration')
    grok.require('waeup.handleStudent')
    grok.template('enterpin')
    title = 'Start course registration'
    label = 'Start course registration'
    ac_prefix = 'SFE'
    notice = ''
    pnav = 4
    buttonname = 'Start course registration now'

    def update(self, SUBMIT=None):
        if not self.context.getStudent().state in (CLEARED,RETURNING):
            self.flash("Wrong state.")
            self.redirect(self.url(self.context))
            return
        self.ac_series = self.request.form.get('ac_series', None)
        self.ac_number = self.request.form.get('ac_number', None)

        if SUBMIT is None:
            return
        pin = '%s-%s-%s' % (self.ac_prefix, self.ac_series, self.ac_number)
        code = get_access_code(pin)
        if not code:
            self.flash('Activation code is invalid.')
            return
        # Mark pin as used (this also fires a pin related transition)
        # and fire transition start_clearance
        if code.state == USED:
            self.flash('Activation code has already been used.')
            return
        else:
            comment = u"AC invalidated for %s" % self.context.getStudent().student_id
            # Here we know that the ac is in state initialized so we do not
            # expect an exception, but the owner might be different
            if not invalidate_accesscode(
                pin,comment,self.context.getStudent().student_id):
                self.flash('You are not the owner of this access code.')
                return
        if self.context.getStudent().state == CLEARED:
            IWorkflowInfo(self.context.getStudent()).fireTransition(
                'pay_first_school_fee')
        elif self.context.getStudent().state == RETURNING:
            IWorkflowInfo(self.context.getStudent()).fireTransition(
                'pay_school_fee')
        self.flash('Course registration has been started.')
        self.redirect(self.url(self.context))
        return


class AddStudyLevelActionButton(AddActionButton):
    grok.order(1)
    grok.context(IStudentStudyCourse)
    grok.view(StudyCourseDisplayFormPage)
    grok.require('waeup.handleStudent')
    text = 'Add course list'
    target = 'add'

    @property
    def target_url(self):
        student = self.view.context.getStudent()
        condition1 = student.state != 'school fee paid'
        condition2 = str(student['studycourse'].current_level) in \
            self.view.context.keys()
        if condition1 or condition2:
            return ''
        return self.view.url(self.view.context, self.target)

class AddStudyLevelFormPage(SIRPEditFormPage):
    """ Page for students to add current study levels
    """
    grok.context(IStudentStudyCourse)
    grok.name('add')
    grok.require('waeup.handleStudent')
    grok.template('studyleveladdpage')
    form_fields = grok.AutoFields(IStudentStudyCourse)
    title = 'Study Course'
    pnav = 4

    @property
    def label(self):
        studylevelsource = StudyLevelSource().factory
        code = self.context.current_level
        title = studylevelsource.getTitle(self.context, code)
        return 'Add current level %s' % title

    def update(self):
        if self.context.getStudent().state != 'school fee paid':
            emit_lock_message(self)
            return
        super(AddStudyLevelFormPage, self).update()
        return

    @grok.action('Create course list now')
    def addStudyLevel(self, **data):
        studylevel = StudentStudyLevel()
        studylevel.level = self.context.current_level
        studylevel.level_session = self.context.current_session
        try:
            self.context.addStudentStudyLevel(
                self.context.certificate,studylevel)
        except KeyError:
            self.flash('This level exists.')
        self.redirect(self.url(self.context))
        return

class StudyLevelEditActionButton(ManageActionButton):
    grok.order(1)
    grok.context(IStudentStudyLevel)
    grok.view(StudyLevelDisplayFormPage)
    grok.require('waeup.handleStudent')
    text = 'Add and remove courses'
    target = 'edit'

    @property
    def target_url(self):
        student = self.view.context.getStudent()
        condition1 = student.state != 'school fee paid'
        condition2 = student[
            'studycourse'].current_level != self.view.context.level
        if condition1 or condition2:
            return ''
        return self.view.url(self.view.context, self.target)

class StudyLevelEditFormPage(SIRPEditFormPage):
    """ Page to edit the student study level data by students
    """
    grok.context(IStudentStudyLevel)
    grok.name('edit')
    grok.require('waeup.handleStudent')
    grok.template('studyleveleditpage')
    form_fields = grok.AutoFields(IStudentStudyLevel).omit(
        'level_session', 'level_verdict')
    pnav = 4

    def update(self):
        super(StudyLevelEditFormPage, self).update()
    #    tabs.need()
        datatable.need()
        warning.need()
        return

    @property
    def title(self):
        return 'Study Level %s' % self.context.level_title

    @property
    def label(self):
        return 'Add and remove course tickets of study level %s' % self.context.level_title

    @property
    def total_credits(self):
        total_credits = 0
        for key, val in self.context.items():
            total_credits += val.credits
        return total_credits

    @grok.action('Add course ticket')
    def addCourseTicket(self, **data):
        self.redirect(self.url(self.context, 'ctadd'))

    @jsaction('Remove selected tickets')
    def delCourseTicket(self, **data):
        form = self.request.form
        if form.has_key('val_id'):
            child_id = form['val_id']
        else:
            self.flash('No ticket selected.')
            self.redirect(self.url(self.context, '@@edit'))
            return
        if not isinstance(child_id, list):
            child_id = [child_id]
        deleted = []
        for id in child_id:
            # Students are not allowed to remove core tickets
            if not self.context[id].core_or_elective:
                try:
                    del self.context[id]
                    deleted.append(id)
                except:
                    self.flash('Could not delete %s: %s: %s' % (
                            id, sys.exc_info()[0], sys.exc_info()[1]))
        if len(deleted):
            self.flash('Successfully removed: %s' % ', '.join(deleted))
        self.redirect(self.url(self.context, u'@@edit'))
        return

    @grok.action('Register course list')
    def RegisterCourses(self, **data):
        IWorkflowInfo(self.context.getStudent()).fireTransition('register_courses')
        self.flash('Course list has been registered.')
        self.redirect(self.url(self.context))
        return

class CourseTicketAddFormPage2(CourseTicketAddFormPage):
    """Add a course ticket by student.
    """
    grok.name('ctadd')
    grok.require('waeup.handleStudent')
    form_fields = grok.AutoFields(ICourseTicketAdd).omit(
        'grade', 'score', 'core_or_elective', 'automatic')

    @grok.action('Add course ticket')
    def addCourseTicket(self, **data):
        ticket = CourseTicket()
        course = data['course']
        ticket.automatic = False
        ticket.code = course.code
        ticket.title = course.title
        ticket.faculty = course.__parent__.__parent__.__parent__.title
        ticket.department = course.__parent__.__parent__.title
        ticket.credits = course.credits
        ticket.passmark = course.passmark
        ticket.semester = course.semester
        try:
            self.context.addCourseTicket(ticket)
        except KeyError:
            self.flash('The ticket exists.')
            return
        self.flash('Successfully added %s.' % ticket.code)
        self.redirect(self.url(self.context, u'@@edit'))
        return

class ChangePasswordRequestPage(SIRPForm):
    """Captcha'd page for students to request a password change.
    """
    grok.context(IUniversity)
    grok.name('changepw')
    grok.require('waeup.Anonymous')
    grok.template('changepw')
    title = 'Change Password Request'
    label = 'Change my password'
    form_fields = grok.AutoFields(IStudentChangePassword)

    def update(self):
        # Handle captcha
        self.captcha = getUtility(ICaptchaManager).getCaptcha()
        self.captcha_result = self.captcha.verify(self.request)
        self.captcha_code = self.captcha.display(self.captcha_result.error_code)
        return

    @grok.action('Send request')
    def request(self, **data):
        if not self.captcha_result.is_valid:
            # Captcha will display error messages automatically.
            # No need to flash something.
            return
        # Search student
        cat = queryUtility(ICatalog, name='students_catalog')
        reg_number = data['reg_number']
        email = data['email']
        results = cat.searchResults(
            reg_number=(reg_number, reg_number),
            email=(email,email))
        if len(results) == 0:
            self.flash('No student record found.')
            return
        student = list(results)[0]
        # Change password
        sirp_utils = getUtility(ISIRPUtils)
        pwd = sirp_utils.genPassword()
        IUserAccount(student).setPassword(pwd)
        # Send email with new redentials
        username = student.student_id
        fullname = student.display_fullname
        subject = 'Your SIRP credentials'
        msg = 'You have successfully changed your password for the'
        email_to = student.email
        login_url = self.url(grok.getSite(), 'login')
        success = sirp_utils.sendPassword(fullname,msg,username,
            pwd,login_url,email_to,subject)
        if success:
            self.flash('An email with your user name and password ' +
                'has been sent to %s.' % email_to)
        else:
            self.flash('An smtp server error occurred.')
        return