source: main/waeup.sirp/trunk/src/waeup/sirp/students/viewlets.py @ 7171

import os
import grok
from zope.component import getUtility
from zope.interface import Interface
from waeup.sirp.interfaces import (
    IWAeUPObject, IExtFileStore, IFileStoreNameChooser)
from waeup.sirp.utils.helpers import string_from_bytes, file_size
from waeup.sirp.browser import DEFAULT_IMAGE_PATH
from waeup.sirp.students.browser import (
    StudentClearanceDisplayFormPage, StudentClearanceManageFormPage,
    write_log_message, StudentBaseManageFormPage, StudentBaseDisplayFormPage,
    StudentFilesUploadPage)
from waeup.sirp.students.interfaces import IStudent, IStudentClearance

grok.context(IWAeUPObject) # Make IWAeUPObject the default context
grok.templatedir('browser_templates')

ALLOWED_FILE_EXTENSIONS = ('jpg', 'png', 'pdf', 'tif')

class StudentManageSidebar(grok.ViewletManager):
    grok.name('left_studentmanage')

class StudentManageLink(grok.Viewlet):
    """A link displayed in the student box which shows up for StudentNavigation
    objects.

    """
    grok.baseclass()
    grok.viewletmanager(StudentManageSidebar)
    grok.context(IWAeUPObject)
    grok.view(Interface)
    grok.order(5)
    grok.require('waeup.viewStudent')

    link = 'index'
    text = u'Base Data'

    def render(self):
        url = self.view.url(self.context.getStudent(), self.link)
        return u'<div class="portlet"><a href="%s">%s</a></div>' % (
                url, self.text)

class StudentManageBaseLink(StudentManageLink):
    grok.order(1)
    link = 'index'
    text = u'Base Data'

class StudentManageClearanceLink(StudentManageLink):
    grok.order(2)
    link = 'view_clearance'
    text = u'Clearance Data'

class StudentManagePersonalLink(StudentManageLink):
    grok.order(2)
    link = 'view_personal'
    text = u'Personal Data'

class StudentManageStudyCourseLink(StudentManageLink):
    grok.order(3)
    link = 'studycourse'
    text = u'Study Course'

class StudentManagePaymentsLink(StudentManageLink):
    grok.order(4)
    link = 'payments'
    text = u'Payments'

class StudentManageAccommodationLink(StudentManageLink):
    grok.order(5)
    link = 'accommodation'
    text = u'Accommodation Data'

class StudentManageHistoryLink(StudentManageLink):
    grok.order(6)
    link = 'history'
    text = u'History'


class StudentMenu(grok.ViewletManager):
    grok.name('top_student')

class StudentLink(grok.Viewlet):
    """A link displayed in the student box which shows up for StudentNavigation
    objects.

    """
    grok.baseclass()
    grok.viewletmanager(StudentMenu)
    grok.context(IWAeUPObject)
    grok.view(Interface)
    grok.order(5)
    grok.require('waeup.viewStudent')
    template = grok.PageTemplateFile('browser_templates/plainactionbutton.pt')

    link = 'index'
    text = u'Base Data'

    @property
    def target_url(self):
        """Get a URL to the target...
        """
        return self.view.url(self.context.getStudent(), self.link)

class StudentBaseLink(StudentLink):
    grok.order(1)
    link = 'index'
    text = u'Base Data'

class StudentClearanceLink(StudentLink):
    grok.order(2)
    link = 'view_clearance'
    text = u'Clearance Data'

class StudentPersonalLink(StudentLink):
    grok.order(2)
    link = 'view_personal'
    text = u'Personal Data'

class StudentStudyCourseLink(StudentLink):
    grok.order(3)
    link = 'studycourse'
    text = u'Study Course'

class StudentPaymentsLink(StudentLink):
    grok.order(4)
    link = 'payments'
    text = u'Payments'

class StudentAccommodationLink(StudentLink):
    grok.order(5)
    link = 'accommodation'
    text = u'Accommodation'

class StudentHistoryLink(StudentLink):
    grok.order(6)
    link = 'history'
    text = u'History'

class PrimaryStudentNavManager(grok.ViewletManager):
    """Viewlet manager for the primary navigation tab.
    """
    grok.name('primary_nav_student')

class PrimaryStudentNavTab(grok.Viewlet):
    """Base for primary student nav tabs.
    """
    grok.baseclass()
    grok.viewletmanager(PrimaryStudentNavManager)
    grok.template('primarynavtab')
    grok.order(1)
    grok.require('waeup.View')
    pnav = 0 
    tab_title = u'Some Text'

    @property
    def link_target(self):
        return self.view.application_url()

    @property
    def active(self):
        view_pnav = getattr(self.view, 'pnav', 0)
        if view_pnav == self.pnav:
            return 'active'
        return ''

class HomeTab(PrimaryStudentNavTab):
    """Home-tab in primary navigation.
    """
    grok.order(1)
    grok.require('waeup.Public')
    pnav = 0
    tab_title = u'Home'

class ProspectusTab(PrimaryStudentNavTab):
    """Faculties-tab in primary navigation.
    """
    grok.order(2)
    grok.require('waeup.View')
    pnav = 1
    tab_title = u'Prospectus'

    @property
    def link_target(self):
        return self.view.application_url('faculties')

class MyDataTab(PrimaryStudentNavTab):
    """MyData-tab in primary navigation.
    """
    grok.order(3)
    grok.require('waeup.Public')
    pnav = 4
    tab_title = u'My Data'

    @property
    def link_target(self):
        rel_link = '/students/%s' % self.request.principal.id
        return self.view.application_url() + rel_link

def handle_file_delete(context, view, download_name):
    """Handle deletion of student file.

    """
    store = getUtility(IExtFileStore)
    store.deleteFileByContext(context, attr=download_name)
    write_log_message(view, 'deleted: %s' % download_name)
    view.flash('%s deleted.' % download_name)
    return

def handle_file_upload(upload, context, view, max_size, download_name=None):
    """Handle upload of student file.

    Returns `True` in case of success or `False`.

    Please note that file pointer passed in (`upload`) most probably
    points to end of file when leaving this function.
    """
    # Check some file requirements first
    if upload.filename.count('.') == 0:
        view.flash('File name has no extension.')
        return False
    if upload.filename.count('.') > 1:
        view.flash('File name contains more than one dot.')
        return False
    basename, expected_ext = os.path.splitext(download_name)
    dummy, ext = os.path.splitext(upload.filename)
    ext.lower()
    if expected_ext:
        if ext != expected_ext:
            view.flash('%s file extension expected.' %
                expected_ext.replace('.',''))
            return False
    else:
        if not ext.replace('.','') in ALLOWED_FILE_EXTENSIONS:
            view.flash(
                'Only the following extension are allowed: %s' %
                ', '.join(ALLOWED_FILE_EXTENSIONS))
            return False
        download_name += ext
    size = file_size(upload)
    if size > max_size:
        view.flash('Uploaded file is too big.')
        return False
    upload.seek(0) # file pointer moved when determining size
    store = getUtility(IExtFileStore)
    file_id = IFileStoreNameChooser(context).chooseName(attr=download_name)
    store.createFile(file_id, upload)
    write_log_message(view, 'uploaded: %s (%s)' % (download_name,upload.filename))
    view.flash('File %s uploaded.' % download_name)
    return True

class FileManager(grok.ViewletManager):
    """Viewlet manager for uploading files, preferably scanned images.
    """
    grok.name('files')

class FileDisplay(grok.Viewlet):
    """Base file display viewlet.
    """
    grok.baseclass()
    grok.context(IStudentClearance)
    grok.viewletmanager(FileManager)
    grok.view(StudentClearanceDisplayFormPage)
    grok.template('filedisplay')
    grok.order(1)
    grok.require('waeup.viewStudent')
    label = u'File:'
    title = u'Scan'
    download_name = u'filename.jpg'

    @property
    def file_exists(self):
        image = getUtility(IExtFileStore).getFileByContext(
            self.context, attr=self.download_name)
        if image:
            return True
        else:
            return False

class FileUpload(FileDisplay):
    """Base upload viewlet.
    """
    grok.baseclass()
    grok.context(IStudentClearance)
    grok.viewletmanager(FileManager)
    grok.view(StudentClearanceManageFormPage)
    grok.template('fileupload')
    grok.require('waeup.uploadStudentFile')
    tab_redirect = ''
    mus = 1024 * 150

    @property
    def input_name(self):
        return "%s" % self.__name__

    def update(self):
        self.max_upload_size = string_from_bytes(self.mus)
        delete_button = self.request.form.get(
            'delete_%s' % self.input_name, None)
        upload_button = self.request.form.get(
            'upload_%s' % self.input_name, None)
        if delete_button:
            handle_file_delete(
                context=self.context, view=self.view,
                download_name=self.download_name)
            self.view.redirect(
                self.view.url(
                    self.context, self.view.__name__) + self.tab_redirect)
            return
        if upload_button:
            upload = self.request.form.get(self.input_name, None)
            if upload:
                # We got a fresh upload
                handle_file_upload(upload,
                    self.context, self.view, self.mus, self.download_name)
                self.view.redirect(
                    self.view.url(
                        self.context, self.view.__name__) + self.tab_redirect)
            else:
                self.view.flash('No local file selected.')
                self.view.redirect(
                    self.view.url(
                        self.context, self.view.__name__) + self.tab_redirect)
        return

class PassportDisplay(FileDisplay):
    """Passport display viewlet.
    """
    grok.order(1)
    grok.context(IStudent)
    grok.view(StudentBaseDisplayFormPage)
    grok.require('waeup.viewStudent')
    grok.template('imagedisplay')
    label = u'Passport Picture:'
    download_name = u'passport.jpg'

class PassportUploadManage(FileUpload):
    """Passport upload viewlet for officers.
    """
    grok.order(1)
    grok.context(IStudent)
    grok.view(StudentBaseManageFormPage)
    grok.require('waeup.manageStudent')
    grok.template('imageupload')
    label = u'Passport Picture (jpg only):'
    mus = 1024 * 50
    download_name = u'passport.jpg'
    tab_redirect = '#tab-2'

class PassportUploadEdit(PassportUploadManage):
    """Passport upload viewlet for students.
    """
    grok.view(StudentFilesUploadPage)
    grok.require('waeup.uploadStudentFile')

class BirthCertificateDisplay(FileDisplay):
    """Birth Certificate display viewlet.
    """
    grok.order(1)
    label = u'Birth Certificate:'
    title = u'Birth Certificate Scan'
    download_name = u'birth_certificate'

class BirthCertificateUpload(FileUpload):
    """Birth Certificate upload viewlet.
    """
    grok.order(1)
    label = u'Birth Certificate:'
    title = u'Birth Certificate Scan'
    mus = 1024 * 150
    download_name = u'birth_certificate'
    tab_redirect = '#tab-2'

class AcceptanceLetterDisplay(FileDisplay):
    """Acceptance Letter display viewlet.
    """
    grok.order(1)
    label = u'Acceptance Letter:'
    title = u'Acceptance Letter Scan'
    download_name = u'acceptance_letter'

class AcceptanceLetterUpload(FileUpload):
    """AcceptanceLetter upload viewlet.
    """
    grok.order(2)
    label = u'Acceptance Letter:'
    title = u'Acceptance Letter Scan'
    mus = 1024 * 150
    download_name = u'acceptance_letter'
    tab_redirect = '#tab-2'

class Image(grok.View):
    """Renders jpeg images for students.
    """
    grok.baseclass()
    grok.name('none.jpg')
    grok.context(IStudentClearance)
    grok.require('waeup.viewStudent')
    download_name = u'none.jpg'

    def render(self):
        # A filename chooser turns a context into a filename suitable
        # for file storage.
        image = getUtility(IExtFileStore).getFileByContext(
            self.context, attr=self.download_name)
        if image is None:
            # show placeholder image
            self.response.setHeader('Content-Type', 'image/jpeg')
            return open(DEFAULT_IMAGE_PATH, 'rb').read()
        dummy,ext = os.path.splitext(image.name)
        if ext == '.jpg':
            self.response.setHeader('Content-Type', 'image/jpeg')
        elif ext == '.png':
            self.response.setHeader('Content-Type', 'image/png')
        elif ext == '.pdf':
            self.response.setHeader('Content-Type', 'application/pdf')
        elif ext == '.tif':
            self.response.setHeader('Content-Type', 'image/tiff')
        return image

class Passport(Image):
    """Renders jpeg passport picture.
    """
    grok.name('passport.jpg')
    download_name = u'passport.jpg'
    grok.context(IStudent)

class BirthCertificateImage(Image):
    """Renders birth certificate jpeg scan.
    """
    grok.name('birth_certificate')
    download_name = u'birth_certificate'

class AcceptanceLetterImage(Image):
    """Renders acceptance letter jpeg scan.
    """
    grok.name('acceptance_letter')
    download_name = u'acceptance_letter'