source: main/waeup.sirp/branches/ulif-extimgstore/src/waeup/sirp/applicants/applicant.py @ 7002

##
## applicants.py
## Login : <uli@pu.smp.net>
## Started on  Fri Jul 16 11:46:55 2010 Uli Fouquet
## $Id$
## 
## Copyright (C) 2010 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
##
import os
import grok
from grok import index
from zope.component import getUtility
from zope.component.interfaces import IFactory
from zope.interface import implementedBy
from hurry.workflow.interfaces import IWorkflowInfo, IWorkflowState
from waeup.sirp.interfaces import IObjectHistory, IExtFileStore
from waeup.sirp.app import University
from waeup.sirp.applicants.interfaces import (
    IResultEntry, IApplicant, IApplicantEdit, default_passport_image,
    )
from waeup.sirp.image import WAeUPImageFile
from waeup.sirp.utils.helpers import attrs_to_fields

def get_regno_or_ac(context):
    reg_no = getattr(context, 'reg_no', None)
    if reg_no is None:
        return getattr(context, 'access_code', None)
    return reg_no

class ResultEntry(grok.Context):
    grok.implements(IResultEntry)

    def __init__(self, subject=None, score=None):
        self.subject = subject
        self.score = score

class Applicant(grok.Model):
    grok.implements(IApplicant,IApplicantEdit)
    grok.provides(IApplicant)

    def __init__(self):
        super(Applicant, self).__init__()
        IWorkflowInfo(self).fireTransition('init')
        self.application_date = None
        return

    #def getApplicantsRootLogger(self):
    #    return grok.getSite()['applicants'].logger

    def loggerInfo(self, ob_class, comment=None):
        target = self.__name__
        return grok.getSite()['applicants'].logger_info(ob_class,target,comment)

    @property
    def state(self):
        state = IWorkflowState(self).getState()
        return state

    @property
    def history(self):
        history = IObjectHistory(self)
        return history

# Set all attributes of Applicant required in IApplicant as field
# properties. Doing this, we do not have to set initial attributes
# ourselves and as a bonus we get free validation when an attribute is
# set.
Applicant = attrs_to_fields(Applicant)

class ApplicantCatalog(grok.Indexes):
    """A catalog indexing :class:`Applicant` instances in the ZODB.
    """
    grok.site(University)
    grok.name('applicants_catalog')
    grok.context(IApplicant)

    access_code = index.Field(attribute='access_code')

#class ApplicantTraverser(grok.Traverser):
#    """Get image of the context applicant.
#
#    Each applicant can provide a passport photograph which will be
#    returned by this traverser if:
#
#    - we request the exact filename of the picture or
#
#    - ask for a picture named 'passport.jpg'.
#
#    If no picture was stored yet, we get a placeholder image when
#    asking for `passport.jpg`.
#
#    If none of the above applies, we return ``None``, most probably
#    resulting a :exc:`NotFound` exception.
#
#    """
#    grok.context(IApplicant)
#    def traverse(self, name):
#        if name != 'passport.jpg':
#            return
#        marked_filename = '__img_appl__%s.jpg' % (
#            get_regno_or_ac(self.context))
#        image = getUtility(IExtFileStore).getFile(marked_filename)
#        if image is None:
#            # Return placeholder
#            from waeup.sirp.applicants.interfaces import IMAGE_PATH
#            return open(os.path.join(IMAGE_PATH, 'placeholder_m.jpg'), 'rb')
#            pass
#        return image #WAeUPImageFile(marked_filename, image.read())
#        if not hasattr(self.context, 'passport'):
#            return None
#        passport_filename = getattr(self.context.passport, 'filename', None)
#        if name == passport_filename:
#            return self.context.passport
#        if name == 'passport.jpg':
#            if self.context.passport is not None:
#                return self.context.passport
#        return

class ApplicantFactory(grok.GlobalUtility):
    """A factory for applicants.
    """
    grok.implements(IFactory)
    grok.name(u'waeup.Applicant')
    title = u"Create a new applicant.",
    description = u"This factory instantiates new applicant instances."

    def __call__(self, *args, **kw):
        return Applicant()

    def getInterfaces(self):
        return implementedBy(Applicant)

from waeup.sirp.interfaces import IFileStoreHandler, IFileStoreNameChooser
from waeup.sirp.imagestorage import DefaultFileStoreHandler

APPLICANT_IMAGE_STORE_NAME = 'img-applicant'

class ApplicantImageNameChooser(grok.Adapter):
    grok.context(IApplicant)
    grok.implements(IFileStoreNameChooser)

    def checkName(self, name=None):
        return name == self.chooseName(name, self.context)

    def chooseName(self, name=None):
        parent_name = getattr(
            getattr(self.context, '__parent__', None),
            '__name__', '_default')
        marked_filename = '__%s__%s/%s.jpg' % (
            APPLICANT_IMAGE_STORE_NAME,
            parent_name, get_regno_or_ac(self.context))
        return marked_filename


class ApplicantImageStoreHandler(DefaultFileStoreHandler, grok.GlobalUtility):
    """Applicant specific image handling.

    This handler knows in which path in a filestore to store applicant
    images and how to turn this kind of data into some (browsable)
    file object.

    It is called from the global file storage, when it wants to
    get/store a file with a file id starting with
    ``__img-applicant__`` (the marker string for applicant images).

    Like each other file store handler it does not handle the files
    really (this is done by the global file store) but only computes
    paths and things like this.
    """
    grok.implements(IFileStoreHandler)
    grok.name(APPLICANT_IMAGE_STORE_NAME)

    def pathFromFileID(self, store, root, file_id):
        """All applicants images are filed in directory ``applicants``.
        """
        marker, filename, basename, ext = store.extractMarker(file_id)
        return os.path.join(root, 'applicants', filename)

    def createFile(self, store, root, filename, file_id, file):
        """Create a browsable file-like object.
        """
        # possible other actions: check for jpeg format
        path = self.pathFromFileID(store, root, file_id)
        return file, path, WAeUPImageFile(filename, file_id)