# -*- coding: utf-8
# -*- Mode: Python; py-indent-offset: 4 -*-
# $Id$
#
# Copyright (c) 2006, Vahur Rebas <vahur@tlu.ee>
#
# Permission to use, copy, modify, and distribute this software for any
# purpose with or without fee is hereby granted, provided that the above
# copyright notice and this permission notice appear in all copies.
#
# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
# WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
# MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
# ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
# WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
# ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
# OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
           

""" Storage for packages.
zip files be automatically unzipped and examined. """

__version__ = "$Revision$"[11:-2]
seen = []

import Globals
from Globals import Acquisition, Persistent
from Acquisition import aq_base, aq_inner, aq_parent, Implicit, Explicit
from AccessControl import ClassSecurityInfo
from OFS.SimpleItem import SimpleItem, getSecurityManager
from OFS.PropertyManager import PropertyManager
from Products.BTreeFolder2.BTreeFolder2 import BTreeFolder2
from ZODB.PersistentMapping import PersistentMapping
from OFS.Traversable import Traversable

import re
from utils import generateId, get_text, getChildNode, gen_key

import logging
logger = logging.getLogger('Caldoz')

class commonGround:
    
    security = ClassSecurityInfo()
    security.declareObjectPublic()

    security.declareProtected('View', 'getChapters')
    def getChapters(self):
        """ get subchapters """
        chaps = self.objectValues('Chapter')
        tmp = []
        res = []
        [ tmp.append([x.orderId, x]) for x in chaps ]
        tmp.sort()
        [ res.append(x[1]) for x in tmp ]
        return res
    

class chapter(Persistent, BTreeFolder2, Implicit, commonGround):
    """ class to store <item>'s and <organization> 
        programmatically there is no difference between <organization> and <item>
        first level chapter will represent <organization> anything else is an <item>
    """
    security = ClassSecurityInfo()
    security.declareObjectPublic()
    meta_type = 'Chapter'

    def __init__(self, title='(untitled)', orderId=0, isvisible=1):
        self.title = title
        self.orderId = orderId
        self.isvisible = isvisible
        BTreeFolder2.__init__(self, self.id)
        self.id = self.generateId(prefix='chapter_')
        self.pagename = ''
        self.identifier = ''
        self.identifierref = ''
        self.adlcp_scormType = ''
        self.parameters = ''
        self.xml_base = ''
        self.options = {
                'hideLMSUI': [], 
                'controlMode': ''
                }
   
    security.declareProtected('View', 'getTitle')
    def getTitle(self):
        return self.title

    security.declareProtected('View', 'index_html')
    def index_html(self, REQUEST):
        """ redirect browser to right page """
        #print "CALDOZ: CHAPTER: index_html", self.getRelativeURL(self), self.xml_base
        if self.getTargetFile():
            return REQUEST.RESPONSE.redirect(self.packageUrl()+'/'+self.xml_base+self.getTargetFile()+self.parameters)
        else:
            chaps = self.getChapters()
            chap = chaps[0]
            if not chap.getTargetFile():
                if chap.getChapters(): chap = chap.getChapters()[0]
            return REQUEST.RESPONSE.redirect(self.packageUrl()+'/'+chap.getTargetFile())

    security.declareProtected('View', 'getTargetFile')
    def getTargetFile(self):
        """ returns pagename what associated with this chapter """
        return self.pagename

    def isChapter(self):
        return True

class packagefile(Persistent, SimpleItem, Explicit):

    meta_type = 'packagefile'
    security = ClassSecurityInfo()
    security.declareObjectPublic()

    def __init__(self, id, rawdata, filename, size):
        self.id = id
        # do some replacing here.
        # 
        # step 1. modify html to use generated links/ids
        # step 2. create a mapping between generated links/ids and packagefile
        # 
        # <script src="../package/folder/some.js" -> src="../package/generated_id"
        # <link href="../package/folder/some.css" -> src="../package/generated_id"
        #
        # <img src="../package/blah/some.gif" -> src="

        # It should be possible to generate session-uniq ids

        #print "Caldoz: packagefile: storing file:", filename
        self._rawdata = rawdata
        self._filename = filename
        self._size = size


    def __getitem__(self, parent):
        return self

    def getFileName(self):
        return self._filename.split('/')[-1]

    def getFileFullPath(self):
        return self._filename

    def _getContent(self):
        return self._rawdata

    def _setContent(self, val):
        self._rawdata = val

    security.declareProtected('View', '__call__')
    def __call__(self):
        #print "CALDOZ: packagefile: __call__:", self._filename
        raise 'Caldoz', 'Where did this come?'
        return self._rawdata

    security.declareProtected('View', 'index_html')
    def index_html(self, REQUEST):
        """ index """
        #print "CALDOZ: packagefile: index_html: ", self._filename
        if self._filename[-3:] == 'css':
            # set content-type text/css
            REQUEST.RESPONSE.setHeader('Content-Type', 'text/css')
            pass
        #else:
        #    REQUEST.RESPONSE.setHeader('Content-Type', 'text/plain')
        return self._rawdata

Globals.InitializeClass(packagefile)

class Package(Persistent, BTreeFolder2, Implicit, PropertyManager, commonGround):
    """ package """

    meta_type = 'CaldozPackage'
    security = ClassSecurityInfo()
    security.declareObjectPublic()

    manage_options = BTreeFolder2.manage_options

    def __init__(self, file, id=None):
        # store the original file
        # itemdemo2.zip
        self.zipfilename = file.filename
        # Content-Disposition: form-data; name="file"; filename="itemdemo2.zip"
        # Content-Type: application/zip
        self.zipheaders = str(file.headers)
        self.zipfile = file.read()
        if id is None:
            self.id = generateId(self, prefix='package_', suffix='_sco', rand_ceiling=999999999)
        else:
            self.id = id
        BTreeFolder2.__init__(self, self.id)
        # information about package itself
        self.default_organization = ''
        self._public_key = gen_key('public')
        self._private_key = gen_key('private')

    def manage_afterAdd(self, item, container):
        self.parseZip()
        self.rewriteLinks()

    def _getPublicKey(self):
        return self._public_key

    def _getPrivateKey(self):
        return self._private_key

    def rewriteLinks(self):
        """ rewrite links 
        script, link img
        """
        links = []
        found = []
        css = []
        for f in self.getFileList():
            # parse only html files
            if f.getFileFullPath().endswith('html'): 
                for rl in re.finditer('<(img|link|script).*?>', f._getContent()):

                    val = rl.group()
                    good_to_add = False
                    if val.startswith('<script') and 'src=' in val:
                        good_to_add = True
                    if val.startswith('<link') and 'href=' in val:
                        good_to_add = True
                    if val.startswith('<img'):
                        good_to_add = True
                    if good_to_add:
                        path = f.getFileFullPath().split('/')
                        # remove filename.. and get folder
                        path.pop()
                        links.append([val, f.id, path])
            if f.getFileFullPath().endswith('css'):
                for rl in re.finditer('url\((.*?)\)', f._getContent()):
                    path = f.getFileFullPath().split('/')
                    path.pop()
                    css.append([rl.group(), f.id, path])

        re_srcpat = re.compile('(src|href)=(\'|")(.*?)(\'|")')

        filemap = {}
        linkseen = []

        # <link rel="stylesheet" href="../Shared Files/css/style.css" type="text/css" />

        for l in links:
            #print l[0], l[2]
            m = re_srcpat.search(l[0])
            if m is None:
                continue
            rl = m.group(3)
            #print "... base@start:", l[2]
            while rl.startswith('../'):
                rl = rl[3:]
                try:
                    l[2].pop()
                except IndexError:
                    pass
            #print l[2]
            combined_path = '/'.join(l[2])+'/'+rl
            if combined_path.startswith('/'): combined_path = combined_path[1:]
            pf = self.getFileByFullpath(combined_path)
            pfid = ' ei leidnud'
            if pf is not None: pfid = pf.id
            #print combined_path, pfid

            # possibly an invalid link or something... try removing first folder
            if pf is None:
                #print " ==== not found ====", combined_path, l[0], l[2]
                #print "trying with less restrictive method", combined_path
                candidates = self.getFileByName(combined_path, full_list=1)
                if len(candidates)==1:
                    pf = candidates[0]
                else:
                    combined_path = combined_path[combined_path.find('/')+1:]
                    pf = self.getFileByFullpath(combined_path)
                    if pf is None:
                        #print "second try with less restrictive method", combined_path
                        #print self.getFileByName(combined_path)
                        import logging
                        logger = logging.getLogger('Caldoz')
                        logger.exception('rewriteUrls: not found:'+combined_path)
                        continue
            
            #print "File",l[1], "links with", combined_path, pfid

            k = 'generated__'+gen_key('mapp')
            if not combined_path in linkseen:
                linkseen.append(combined_path)
                filemap[k] = {'origin': l[0], 'file': pf.id, 'combined': combined_path}
            else:
                for x in filemap.keys():
                    if filemap[x]['combined'] == combined_path:
                        k = x
            # having k
            rewrote = l[0]
            if l[0].startswith('<img'):
                k = self.packageUrl()+'/'+k
            rewrote = re.sub(m.group(1)+'='+m.group(2)+'.*?'+m.group(2), m.group(1)+'="'+k+'"', rewrote)
            #print rewrote
            fo = getattr(self, l[1])
            data = fo._getContent()
            data = re.sub(l[0], rewrote, data)
            fo._setContent(data)

        #print "Starting with CSS files..."
        for c in css:
            #css.append([rl.group(), f.id, path])
            fname = re.search('url\((.*?)\)', c[0]).group(1)
            orig = fname
            
            while fname.startswith('../'):
                fname = fname[3:]
                try:
                    c[2].pop()
                except IndexError:
                    pass
            #print l[2]
            combined_path = '/'.join(c[2])+'/'+fname
            if combined_path.startswith('/'): combined_path = combined_path[1:]
            pf = self.getFileByFullpath(combined_path)
            pfid = ' ei leidnud'
            if pf is not None: pfid = pf.id

            if pf is None:
                continue

            #print "File",c[1], "links with", combined_path, pfid, c[0]
            k = 'generated__'+gen_key('mapp')
            if not combined_path in linkseen:
                linkseen.append(combined_path)
                filemap[k] = {'origin': c[0], 'file': pf.id, 'combined': combined_path}
            else:
                for x in filemap.keys():
                    if filemap[x]['combined'] == combined_path:
                        k = x

            rewrote = k
            if orig.endswith('jpg') or orig.endswith('gif'):
                rewrote = self.packageUrl()+'/'+k
            fo = getattr(self, c[1])
            data = fo._getContent()
            data = re.sub(orig, rewrote, data)
            fo._setContent(data)

        self._setFileMap(filemap)
        return "ok"

    def _setFileMap(self, val):
        self._filemap = val

    def getFileByGen(self, id):
        try:
            if self._filemap.has_key(id):
                return getattr(self, self._filemap[id]['file'])
        except AttributeError:
            pass
        return None

    security.declareProtected('Manage portal', 'parseZip')
    def parseZip(self):
        """ parse zip file, store content """
        #print "Caldoz: Starting zip parsing"
        objs = self.objectIds()
        ids = []
        [ ids.append(x) for x in objs ]
        self.manage_delObjects(ids)
        #while self.objectIds(): # delete all!
        #    self._delObject(objs[0])
        has_manifest = self._unzip_and_store()
        if not has_manifest:
            raise 'Zip file doesn\'t contain manifest'
        self.parseManifest()

    security.declarePrivate('_unzip_and_store')
    def _unzip_and_store(self):
        import zipfile
        import tempfile
        fname = tempfile.mkstemp()[1]
        f = open(fname, "w+b")
        f.write(self.zipfile)
        f.close()

        #print fname
        zip = zipfile.ZipFile(fname, "r")
        for name in zip.namelist():
            zipinfo = zip.getinfo(name)
            #print "-->", name, zipinfo.flag_bits, zipinfo.filename
            fcontent = zip.read(name)


            pf = packagefile(
                id = self.generateId(prefix='file'),
                rawdata = fcontent, 
                filename = zipinfo.filename,
                size = zipinfo.file_size
                )
            self._setObject(pf.id, pf)

            
        # finally remove tempfile
        import os
        os.unlink(fname)
        return self.getFileByFullpath('imsmanifest.xml')

    security.declarePrivate('parseManifest')
    def parseManifest(self):
        """ parse imsmanifest.xml """
        #print " ------------------------- parsing manifest ------------------------- "
        import xml.dom.minidom as minidom
        xmlstring = self.getFileByFullpath('imsmanifest.xml')._rawdata
        doc = minidom.parseString(xmlstring)
        doc.normalize()
        root = doc.documentElement
        meta_elem = getChildNode(root, 'metadata')
        manifest_identifier = root.getAttribute('identifier')
        default_organization = root.getElementsByTagName('organizations')[0].getAttribute('default')
        orgs = root.getElementsByTagName('organization')
        #chapters['default'] = default_organization
        self.default_organization = default_organization
        orderCount = 0
        for org in orgs:
            organization_identifier = org.getAttribute('identifier')
            title = '(untitled)'
            tit_node = getChildNode(org, 'title')
            if not tit_node:
                #print 'no title!?'
                pass
            title = get_text(tit_node)
            # package or organization title is now in title variable
            chap = chapter(title, orderId=orderCount)
            self._recurseItems(root, chap, org)
            self._setObject(chap.id, chap)
            orderCount = orderCount + 1

    security.declarePrivate('_recurseItems')
    def _recurseItems(self, doc, storage, elem):
        """ recurse through <item>'s """
        orderCount = 0
        for item in elem.childNodes:
            if not item.nodeName.lower() == 'item': continue # only iterested in <item>'s
            ident = item.getAttribute('identifier')
            ident_ref = item.getAttribute('identifierref')
            parameters = item.getAttribute('parameters')
            visible = item.getAttribute('isvisible')
            visible = True
            if visible != 'true':
                visible = False
            title = get_text(item.getElementsByTagName('title')[0]) # there has to be title
            subchap = chapter(title, orderId=orderCount, isvisible=visible)
            subchap.identifier = ident
            subchap.identifierref = ident_ref
            subchap.parameters = parameters
            subchap.options = self._parseSettings(item)
            if ident_ref:
                self._parseResource(doc, subchap, ident_ref)
            storage._setObject(subchap.id, subchap)
            self._recurseItems(doc, subchap, item)
            orderCount = orderCount + 1

    security.declarePrivate('_parseSettings')
    def _parseSettings(self, elem):
        """ parse ims ss rules 
        imsss:controlMode choiceExit=true flow=true
        imsss:deliveryControls completionSetByContent=true objectiveSetByContent=true
        
        CAM 1.3
        adlnav:presentation
        
        """
        for x in elem.childNodes:
            if x.nodeName.lower() in ['#text', 'title', 'item']:
                continue
            if x.nodeName not in seen:
                #print "CHILD NODENAME", x.nodeName
                seen.append(x.nodeName)
        return

    security.declarePrivate('_parseResource')
    def _parseResource(self, doc, obj, identifier):
        """ find and parse element which is identified by identifier. stores data to obj. doc is xml element """
        elem = None
        # it's most likely <resource>
        resources = doc.getElementsByTagName('resource')
        for res in resources:
            if res.getAttribute('identifier') == identifier:
                elem = res
        # if not found, try manifests
        if not elem:
            manis = doc.getElementsByTagName('manifest')
            for res in manis:
                if res.getAttribute('identifier') == identifier:
                    elem = res
        href = elem.getAttribute('href')
        atype = elem.getAttribute('type')
        xml_base = elem.getAttribute('xml:base')
        obj.pagename = href
        obj.atype = atype
        obj.adlcp_scormType = elem.getAttribute(u'adlcp:scormType')
        obj.xml_base = xml_base

    def __bobo_traverse__(self, REQUEST, name):
        qname = name
        stack = REQUEST.get('TraversalRequestNameStack')
        logger.info("------------- new round ---------------"+str(name)+" "+ str(stack))
        
        sc = self._checkSession(REQUEST)
        if sc is None:
            logger.info("Session check failed")
            return getattr(self, 'sessionProblem')

        if 'setLMSValues' in stack:
            #print "will return setLMSValues"
            while stack:
                stack.pop()
            return self.setLMSValues(REQUEST)
            #res = self.setLMSValues(REQUEST)
            #print "...about to return..."
            #REQUEST.RESPONSE.setHeader('Content-Type', 'text/xml')
            #print "... and returning:", res
            #return res
        if 'getLMSValues' in stack:
            #print "will return getLMSValues"
            return self.getLMSValues(REQUEST)
        file = None

        # checking filemap!
        sname = qname
        if stack: sname = stack[0]
        shortfile = self.getFileByGen(sname)
        if shortfile:
            while stack:
                stack.pop()
            return shortfile

        if stack:
            stack.reverse()
            tmp = '/'.join(stack)
            qname = name + '/' + tmp
            file = self.getFileByFullpath(qname)
            if file:
                while stack:
                    stack.pop()
            else:
                stack.reverse()
        else:
            file = self.getFileByFullpath(qname)
        if file:
            #print "first return"
            return file
        other = self.getFileByFullpath(name)
        if other:
            stack.reverse()
            tmp = '/'.join(stack)
            file = self.getFileByFullpath(tmp)
            if file:
                #print "second return"
                while stack: stack.pop()
                return file
            stack.reverse()
        if stack:
            file = self.getFileByName(stack[0])
            if file:
                #print "third option...", stack, file
                while stack: stack.pop()
                return file
        #print "CALDOZ: last return fallout" #, getattr(self, name)
        return getattr(self, name)

    security.declareProtected('View', 'getFileByName')
    def getFileByName(self, name, full_list=0):
        res = []
        for x in self.objectValues('packagefile'):
            if x.getFileName() == name:
                if not full_list:
                    return x
                res.append(x)
        if not full_list:
            return None
        return res
    
    security.declareProtected('View', 'getFileByFullpath')
    def getFileByFullpath(self, name):
        pfs = self.objectValues('packagefile')
        for x in pfs:
            #print "CALDOZ: comparing:", x.getFileFullPath(), name
            if x.getFileFullPath() == name:
                #print "found", x.getFileName(), x.getFileFullPath()
                return x
        # not found, checking relative
        matches = []
        for x in pfs:
            if name in x.getFileFullPath():
                matches.append(x)
        if len(matches)>1:
            def outer(arr):
                return str([x.getId() for x in matches])
                    
            raise 'CALDOZ', 'PANIC, Multiple matches: '+outer(matches)
        if len(matches)==1:
            return matches[0]
        return None

    def index_html(self, REQUEST):
        """ index_html -> package_index """
        return self.package_index()

    security.declareProtected('Manage portal', 'getFileList')
    def getFileList(self):
        return self.objectValues('packagefile')

    #security.declareProtected('Manage portal', 'getOrigZipName')
    def getOrigZipName(self):
        return self.zipfilename

    security.declareProtected('View', 'packageUrl')
    def packageUrl(self):
        return self.absolute_url()

    security.declareProtected('View', 'getMainTitles')
    def getMainTitles(self):
        a = self.objectValues('Chapter')
        res = []
        [ res.append([x.getTitle(), x.absolute_url()]) for x in a ]
        return res

    #security.declareProtected('View', 'getStartingPage')
    def getStartingPage(self):
        """ get first page """
        obj = self.objectValues('Chapter')
        if len(obj)==0: return ""
        res = []
        [ res.append([x.orderId, x]) for x in obj ]
        res.sort()
        return self.getRelativeURL(res[0][1])

    security.declarePublic('getLMSValues')
    def getLMSValues(self, REQUEST):
        """ return SCORM datamodel's values 
            cmi.core.lesson_status

        Notes
        cmi.comments_from_learner{._children, ._count, .n.comment}
            GetValue('cmi.comments_from_learner._children')
        
        """
        import copy
        sk = REQUEST.get('session_key', '')
        sess = getattr(self.sessions, sk, None)

        #print "----------------------- getLMSValues -----------------"
        if not hasattr(self, 'datamodel'):
            self.datamodel = {}
        dm = copy.copy(self.datamodel)
        dm['cmi.learner_name'] = sess.uname
        dm['cmi._version'] = '1.0'
        dm['cmi.completion_status'] = 'not_attempted'
        dm['cmi.core.lesson_status'] = 'not attempted'
        r = []
        for x in dm.keys():
            r.append(x)
            r.append(dm[x])
        return r

    security.declareProtected('View', 'setLMSValues')
    def setLMSValues(self, REQUEST):
        """ save SCORM datamodel's values """
        import time, re
        t = re.sub('\.', '', str(time.time()))
        #print "--------T:", t
        if not hasattr(self, 'user_data'):
            self.user_data = PersistentMapping()
        self.user_data[t] = {}
        for k in REQUEST.form.keys():
            self.user_data[t][k] = REQUEST.form.get(k)
        self._p_changed = True
        self.user_data._p_changed = True
        REQUEST.RESPONSE.setHeader('Content-Type', 'text/xml')
        return "<response><status>0</status></response>"

    def isChapter(self):
        return False

    #security.declareProtected('View', 'getNextChapter')
    def getNextChapter(self, REQUEST, loc=None):
        """ return next chapter """
        #print "CALDOZ: locate next chapter", loc
        #print REQUEST.form.keys()
        # XXX: rewrite: first try to find subchapters!
        if loc is None:
            return ''
        if self.packageUrl() in loc:
            chapurl = loc[len(self.packageUrl())+1:].split('/')
        else:
            chapurl = loc.split('/')
        c = self

        for x in chapurl:
            c = getattr(c, x)

        # try to find next subchapter...
        subchapters = c.getChapters()
        if len(subchapters)>0:
            return self.getRelativeURL(subchapters[0])

        c = self
        for x in chapurl:
            c = getattr(c, x)

        while c.isChapter():
            ordnum = c.orderId
            for x in c.aq_parent.getChapters():
                if x.orderId == ordnum + 1:
                    return self.getRelativeURL(x)
            c = c.aq_parent

        #print "NEXT CHAPTER:", loc
        return loc

    #security.declareProtected('View', 'getPrevChapter')
    def getPrevChapter(self, REQUEST, loc=None):
        """ return next chapter """
        # XXX: rewrite: first try to find subchapters!
        if loc is None:
            return ''
        if self.packageUrl() in loc:
            chapurl = loc[len(self.packageUrl())+1:].split('/')
        else:
            chapurl = loc.split('/')
        c = self

        for x in chapurl:
            c = getattr(c, x)

        def recurse_in(obj):
            chaps = obj.getChapters()
            while len(chaps)>0:
                obj = chaps[-1]
                chaps = obj.getChapters()
            return self.getRelativeURL(obj)

        while c.isChapter():
            ordnum = c.orderId
            for x in c.aq_parent.getChapters():
                if x.orderId == ordnum - 1:
                    # should recurse in
                    return recurse_in(x)
            c = c.aq_parent

        return loc

    def getTOC(self, obj=None, msg='', level=0):
        """ get Table Of Content """
        if obj is None:
            obj = self
        for x in obj.getChapters():
            msg += '<div class="indent'+str(level)+'" style="'
            if level > 1: msg += 'display:none'
            else: msg += 'display:block'
            msg += '">'
            childs = x.getChapters()
            if childs:
                msg += '<span onclick="javascript:menu_collapse(event)" style="cursor:pointer">'
                if level > 0: msg += '+'
                else: msg += '-'
                msg += '</span>'
            else:
                msg += '<span onclick="javascript:menu_collapse(event)">&nbsp;</span>'
            msg += '<a href="'+self.getRelativeURL(x)+'" target="targ" onclick="javascript:put_next(event, \''+self.getRelativeURL(x)+'\')">'
            msg += x.getTitle()
            msg += '</a>'
            msg += self.getTOC(x, '', level+1)
            msg += '</div>'
        return msg

    def _checkSession(self, REQUEST):
        if isinstance(REQUEST, dict):
            #print "ignoring", REQUEST
            return 1
        sk = REQUEST.get('session_key', '')
        sess = getattr(self.sessions, sk, None)
        if sess is None: return None
        if sess.isManager(): return sess
        if self.getId() != sess.package_id: 
            #print "CALDOZ: error 2"
            return None
        if self._getPublicKey() != sess.access_key and self._getPrivateKey() != sess.access_key: 
            #print "CALDOZ: error 3", self._getPrivateKey(), se
            return None
        return sess


    def sessionProblem(self, REQUEST):
        """ report session problem """
        return REQUEST.RESPONSE.redirect('../caldoz_index')

Globals.InitializeClass(Package)

# EOF