root/trunk/Collection.py

# Copyright 2006 by the LeMill Team (see AUTHORS)
#
# This file is part of LeMill.
#
# LeMill 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.
#
# LeMill 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 LeMill; if not, write to the Free Software
# Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

from Products.Archetypes.public import *
from Products.ATReferenceBrowserWidget.ATReferenceBrowserWidget import ReferenceBrowserWidget
from Products.CMFCore.permissions import ModifyPortalContent
from Products.Archetypes.atapi import DisplayList
from Globals import InitializeClass
from Products.CMFCore.utils import getToolByName
from AccessControl import ClassSecurityInfo, Unauthorized
from LargeSectionFolder import LeMillFolder
from Products.ZCatalog.CatalogBrains import AbstractCatalogBrain
from Acquisition import aq_base, aq_inner, aq_parent


from config import PROJECTNAME, ALL_CONTENT_TYPES, CONTENT_TYPES, DEFAULT_ICONS, ACTIVITY_TYPES, TOOLS_TYPES, REPOSITORY, TTF_FONTS, to_unicode
from Resource import Resource
from Schemata import resource_schema
from permissions import ModerateContent, MODIFY_CONTENT, ACCESS_CONTENT, VIEW
from FieldsWidgets import WYSIWYMField, LeVisualWidget
from cStringIO import StringIO
import os, urllib, shutil, sys, zipfile, sre, random, time
import urlparse, tempfile, urllib2
from types import ListType, TupleType

try:
    import ho.pisa as pisa
    from reportlab.pdfbase import pdfmetrics, ttfonts
    pdf_enabled=True
except ImportError:
    pdf_enabled=False


collection_schema =  Schema((
    WYSIWYMField('description',
        accessor='Description',
        widget=LeVisualWidget(
            label="Learning and teaching story",
            description="",
            label_msgid='label_learning_story',
            description_msgid='description_description',
            i18n_domain = "lemill",
            visible={'view':'invisible','edit':'visible'},
        ),
    ),
    
    ReferenceField('relatedContent',
        relationship = 'relatesToContent',
        multiValued = True,
        isMetadata = True,
        languageIndependent = False,
        index = None,
        write_permission = ModifyPortalContent,
        allowed_types= ALL_CONTENT_TYPES,
        widget = ReferenceBrowserWidget(
            allow_search = True,
            allow_browse = True,
            show_indexes = False,
            force_close_on_insert = True,
            startup_directory = "content",
            size = 4,
            i18n_domain = "lemill",
            label = "Related Content",
            label_msgid = "label_related_content",
            description = "",
            description_msgid = "help_story_related_content",
            visible = {'edit' : 'invisible', 'view' : 'invisible' }
            )
        ),
    ReferenceField('relatedMethods',
        relationship = 'relatesToMethods',
        multiValued = True,
        isMetadata = True,
        languageIndependent = False,
        index = None,
        write_permission = ModifyPortalContent,
        allowed_types=('Document','Activity',),
        widget = ReferenceBrowserWidget(
            allow_search = True,
            allow_browse = True,
            show_indexes = False,
            force_close_on_insert = True,
            startup_directory = "methods",
            size = 4,
            i18n_domain = "lemill",
            label = "Related Methods",
            label_msgid = "label_related_methods",
            description = "",
            description_msgid = "help_story_related_methods",
            visible = {'edit' : 'invisible', 'view' : 'invisible' }
            )
        ),
    ReferenceField('relatedTools',
        relationship = 'relatesToTools',
        multiValued = True,
        isMetadata = True,
        languageIndependent = False,
        index = None,
        write_permission = ModifyPortalContent,
        allowed_types=('Document','Tool',),
        widget = ReferenceBrowserWidget(
            allow_search = True,
            allow_browse = True,
            show_indexes = False,
            force_close_on_insert = True,
            startup_directory = "tools",
            size = 4,

            i18n_domain = "lemill",
            label = "Related Tools",
            label_msgid = "label_related_tools",
            description = "",
            description_msgid = "help_story_related_tools",
            visible = {'edit' : 'invisible', 'view' : 'invisible' }
            )
        ),
    ReferenceField('relatedCollections',
        relationship = 'relatesToCollections',
        multiValued = True,
        isMetadata = True,
        languageIndependent = False,
        index = None,
        write_permission = ModifyPortalContent,
        allowed_types=('Document','Collection',),
        widget = ReferenceBrowserWidget(
            allow_search = True,
            allow_browse = True,
            show_indexes = False,
            force_close_on_insert = True,
            startup_directory = "community",
            size = 4,
            i18n_domain = "lemill",
            label = "Related Collections",
            description = "",
            visible = {'edit' : 'invisible', 'view' : 'invisible' }
            )
        ),
    BooleanField('goodStory',
        index = 'FieldIndex',
        default=False,
        isMetadata = True
        ),
    ComputedField('language',
        index='FieldIndex:schema',
        accessor='Language',
        expression = 'here.combineCollectionLanguage()',
        isMetadata = True
        )
))

schema = resource_schema + collection_schema

schema = schema.copy()

class Collection(Resource):
    """Collection"""
    
    schema = schema
    actions= (
    {
    'id':'view',
    'name':'view',
    'action':'string:${object_url}/collection_view',
    'permission':('View',),
    },
    {
    'id':'edit',
    'name':'Edit',
    'action':'string:${object_url}/base_edit',
    'permission':('View',),
    },
    )
    meta_type = "Collection"
    archetype_name = "Collection"  
    typeDescription="Collection of resources."
    typeDescMsgId='description_collection'
    global_allow = 1
    portlet = 'here/portlet_collection_actions/macros/portlet'
    security = ClassSecurityInfo()
    _at_rename_after_creation = True

    def at_post_create_script(self):
        self.at_post_edit_script()

    def at_post_edit_script(self):
        self._renameAfterCreation()
        self. updateStory()

    def after_add_rename(self):
        self._renameAfterCreation()


    security.declarePrivate('_processForm')
    def _processForm(self, data=1, metadata=None, REQUEST=None, values=None):
        request = REQUEST or self.REQUEST
        if values:
            form = values
        else:
            form = request.form
        # Instead of using schema fields, we call them manually
        # (because there are only two)      
        title_field=self.getField('title')
        try:
            title, other = title_field.widget.process_form(self, title_field, form,validating=False)
        except TypeError:
            title, other = title_field.widget.process_form(self, title_field, form)

        self.setTitle(title)
        desc_field=self.getField('description')
        try:
            desc, other = desc_field.widget.process_form(self, desc_field, form,validating=False)
        except TypeError:
            desc, other = desc_field.widget.process_form(self, desc_field, form)
        self.setDescription(desc)
        # Delete & reorder items
        for (reftype,ordered_by) in [('relatedContent','order_'), ('relatedMethods',''), ('relatedTools',''),('relatedCollections','col_order_')]:
            sorted=self.getSortedList(reftype)
            if ordered_by:
                new_list=[]
                for index, item in enumerate(sorted):
                    order=form.get(ordered_by+str(index), 100)
                    new_list.append((order, item))
                new_list.sort()
                new_list=[item.targetUID for (order, item) in new_list]
                self._setOrderedReferences(new_list, reftype)
            # check if deleted
            for item in sorted:
                delete_flag=int(form.get('%s_deleted' % item.targetUID, 0))
                if delete_flag:
                    self._delete(item.targetUID, reftype)
        self.reindexObject()

    security.declarePrivate('_delete')
    def _delete(self, uid, reftype):
        field=self.getField(reftype)
        newlist = [u for u in field.getRaw(self) if u!=uid]
        field.set(self, newlist)
        ltool=getToolByName(self, 'lemill_tool')
        obj=ltool.getObjectByUID(uid)
        if obj:
            obj.recalculateScore()
            obj.reindexObject()

    def setPermissions(self):
        # Setting View permission
        self.manage_permission(VIEW, ('Manager','Owner','Member','Authenticated','Anonymous'), acquire=0)
        # Setting Edit permission
        self.manage_permission(MODIFY_CONTENT, ('Manager','Owner'), acquire=0)
        # Setting Review permission
        self.manage_permission(ModerateContent, ('Manager','Owner','Reviewer'), acquire=0)
        # Setting Access permission
        self.manage_permission(ACCESS_CONTENT, ('Manager','Owner','Member','Authenticated','Anonymous'), acquire=0)
                        
    def detectLanguage(self):
        """ Returns the most used language in content objects of this collection """
        languages={}
        for obj in self.getRelatedContent():
            this_l=obj.Language()
            if this_l:
                languages[this_l]=languages.get(this_l,0)+1
        maxval=max(languages.values())
        for key in languages.keys():
            if languages[key]==maxval:
                return key
        return None                    

    def getMetaDescription(self):
        """ Biography is a good description, but if not filled, then skills, interests or subject areas  """
        desc= self.Description()
        if desc:
            desc_len=0
            desc_result=[]
            ltool = getToolByName(self, 'lemill_tool')        
            desc=ltool.stripHTML(desc)
            for p in desc.split('\n'):
                if p: # ignore empty lines
                    desc_len+=len(p)
                    desc_result.append(p)
                if desc_len > 140:
                    break
            return '\n'.join(desc_result)
        lutool = getToolByName(self, 'lemill_usertool')        
        return "%s's collection of LeMill resources" % lutool.linkTo(self.Creator(), disabled=True)


    def getPathInsideCollection(self, obj):
        """ Returns a path in form portal_url/member/collection/content_section/content_subfolder/content_id """
        if isinstance(obj, AbstractCatalogBrain):
            obj_url=obj.getURL().split('/')
            coll_url=self.absolute_url().split('/')
            portal_url=getToolByName(self, 'portal_url')().split('/')
            return '/'.join(coll_url+obj_url[len(portal_url):])

        path= getattr(obj.__class__, 'default_location','')
        if path:
            return '/'.join((self.absolute_url(), path, obj.id))
        else:
            return '/'.join((self.absolute_url, obj.id))


    def getReferenceType(self, object):
        """ Which reference should be used for this object? Returns string. """
        objtype=object.portal_type
        if objtype in CONTENT_TYPES:
            return 'relatedContent'
        elif objtype in ACTIVITY_TYPES:
            return 'relatedMethods'
        elif objtype in TOOLS_TYPES:
            return 'relatedTools'
        elif objtype == 'Collection':
            return 'relatedCollections'
        else:
            return 'refsToResources'


    def getEmbedCode(self):
        """ Builds a nice embed code """
        return '''<iframe src="%s/collection_clean_view" width="100%%" height="550px" scrolling="auto" frameborder="1"></iframe>''' % self.absolute_url()

        
    security.declareProtected(MODIFY_CONTENT, 'add')
    def add(self, obj):
        """ Add object to collection """
        if type(obj) == ListType or type(obj) == TupleType:
            for x in obj:
                self.add(x)
            return None
        UID=obj.UID()
        reftype=self.getReferenceType(obj)
        field = self.Schema().get(reftype)
        value = field.getRaw(self)
        value.append(UID)
        self._setOrderedReferences(value, reftype)
        self.updateStory()
        obj.recalculateScore()
        obj.reindexObject()
        self.notifyCollectionAdd(obj)

    def updateStory(self):
        """ Recalculate goodStory-field, changed to be done manually because 
        a) to avoid infinite looping
        b) to avoid unnecessary and costly updating of this field """
        old=self.getGoodStory()
        new=self.isThisGoodStory()
        if old != new:
            self.setGoodStory(new)
            self.reindexObject(['getGoodStory'])
            for obj in self.getContent()+self.getMethods()+self.getTools():
                obj.recalculateScore()
                obj.reindexObject(['getScore'])


    def isThisGoodStory(self):
        """ Check if there is content,method,tool and description """        
        if self.state=='deleted':
            return False
        if len(self.Description())<200:
            return False
        #import pdb;pdb.set_trace()
        good_content = False
        good_methods = False
        good_tools = False        
        c=self.getRelatedContent()
        for obj in c:
            if obj.getHasCoverImage() and obj.state == 'public':
                good_content = True
        if not good_content:
            return False
        m=self.getRelatedMethods()
        for obj in m:
            if obj.getHasCoverImage() and obj.state == 'public':
                good_methods = True
        if not good_methods:
            return False
        t=self.getRelatedTools()
        for obj in t:
            if obj.getHasCoverImage() and obj.state == 'public':
                good_tools = True
        return good_tools

    def getItemCount(self):
        """ return how many items are in collection """
        return len(self.getContent()+self.getMethods()+self.getTools()+self.getCollections())


    def getContent(self):
        """ make sure that related content comes in correct order even when programmer forgets to ask for it"""
        return self.getResources('relatedContent')

    def getMethods(self):
        """ don't get deleted methods """
        return self.getResources('relatedMethods')
        
    def getTools(self):
        """ don't get deleted tools """
        return self.getResources('relatedTools')

    def getCollections(self):
        """ don't get deleted collections """
        return self.getResources('relatedCollections')

    def getSortedList(self, reftype='relatedContent'):
        field = self.Schema().get(reftype)
        if reftype == 'relatedMethods' or reftype=='relatedTools':
            sortable = [(ref.targetId(), ref) for ref in self.getReferenceImpl(relationship=field.relationship)]
        else:              
            sortable = [(getattr(ref,'collection_position',100), ref) for ref in self.getReferenceImpl(relationship=field.relationship)]
        sortable.sort()
        return [ref for i, ref in sortable if ref]

    def getBlurp(self):
        """ 200-300 character version of description """
        desc=self.Description()
        if desc:
            lt = getToolByName(self, 'lemill_tool')
            return lt.cropText(lt.parse_text(desc))
        else:
            return ''

    def getResources(self, reftype='relatedContent', private_materials=True, pdf_types=False):
        """ ... """
        user = getToolByName(self, 'lemill_usertool').getAuthenticatedId()
        manager=self.amIManager()        
        resources = []
        for ref in self.getSortedList(reftype):
            print 'ref:', ref
            target = ref.getTargetObject()
            if not target:
                continue
            if pdf_types and target.meta_type not in ['MultimediaMaterial', 'ExerciseMaterial', 'LessonPlan', 'SchoolProjectMaterial', 'LeMillReference', 'Activity', 'Tool']:
                continue
            if target.state=='draft' or target.state=='public':
                resources.append(target)
            elif private_materials and target.state=='private' and (user==target.Creator() or manager):
                resources.append(target)
        return resources


    def getResourcesMetadata(self, reftype='relatedContent'):
        """ ... """
        pc=getToolByName(self, 'portal_catalog')
        user = getToolByName(self, 'lemill_usertool').getAuthenticatedId()
        manager=self.amIManager()        
        results=[]
        for ref in self.getSortedList(reftype):
            md=pc(UID=ref.targetUID)
            if md:
                md=md[0]
            else:
                continue
            if md.getState=='draft' or md.getState=='public':
                results.append(md)
            elif md.getState=='private' and (md.Creator==user or manager):
                results.append(md)
        return results

    def isResourceInCollection(self, resource):
        """ Returns True if the resource belongs to this collection, False otherwise. """
        objects = self.getRelatedContent() + self.getRelatedMethods() + self.getRelatedTools() + self.getRelatedCollections()
        return resource in objects


    
    def getCollectionContent(self):
        """ Returns a list of content, methods, tools and collections for RSS """
        objects=self.getContent()+self.getMethods()+self.getTools()+self.getCollections()
        return objects     


    def _setOrderedReferences(self, ordered_list, reftype='relatedContent'):
        """ setter that stores the index of each element in list with reference object. ordered_list = list of uids """
        field = self.getField(reftype)
        field.set(self, ordered_list)
        refs = self.getReferenceImpl(relationship=field.relationship)
        for ref in refs:
            i = ordered_list.index(ref.targetUID)
            ref.collection_position=i
            
    def getLearningStoryText(self):
        """ will return the nice version for the story text """
        lt = getToolByName(self, 'lemill_tool')
        return lt.parse_text(self.Description())


    # These additional meta-type='' and obj=None might not be needed, but I will leave them here just to be on the safe side.
    def getDefaultIcon(self, meta_type='', obj=None):
        """ Will return a portrait of the creator or his default icon """
        try:
            mf=self.getMemberFolder()
        except AttributeError:
            owner=self.Creator
            lutool = getToolByName(self, 'lemill_usertool')
            mf=lutool.getMemberFolder(owner)
        return mf.getCoverImageURL()

    def getCollection(self):
        return self

    def isCollection(self):
        return True

    def getLatestModificationDate(self):
        """ Looks to latest modification date of all resources """
        return max([x.ModificationDate for x in self.getAllRelatedResources()]+[self.ModificationDate()])

    def getAllRelatedResources(self):
        return self.getResourcesMetadata(reftype='relatedContent') + self.getResourcesMetadata(reftype='relatedMethods') + self.getResourcesMetadata(reftype='relatedTools')+self.getResourcesMetadata(reftype='relatedCollections')

    def getNextAndPrevLinks(self, item):
        """ Returns a tuple where (prev, next) are urls to next and previous items in collection """
        prev=''
        next=''
        resources = self.getAllRelatedResources()
        resources_ids=[r.getId for r in resources]    
        try:
            i = resources_ids.index(item.getId())
        except ValueError: 
            return (prev,next) # No link if item is not in resources
        if i>0:
            prev=resources[i-1]
            prev=self.getPathInsideCollection(prev)
        if i<len(resources)-1:
            next=resources[i+1]
            next=self.getPathInsideCollection(next)
        return (prev, next)

    def getRelatedContentMetadata(self, **kw):
        """ Returns catalog objects """
        pc = getToolByName(self, 'portal_catalog')
        uids = self.getRawRelatedContent()
        query = {'UID':uids}
        query.update(kw)
        objlist = pc(query)
        return objlist

    def getRelatedMethodsMetadata(self, **kw):
        """ Returns catalog objects """
        pc = getToolByName(self, 'portal_catalog')
        uids = self.getRawRelatedMethods()
        query = {'UID':uids}
        query.update(kw)
        objlist = pc(query)
        return objlist

    def getRelatedToolsMetadata(self, **kw):
        """ Returns catalog objects """
        pc = getToolByName(self, 'portal_catalog')
        uids = self.getRawRelatedTools()
        query = {'UID':uids}
        query.update(kw)
        objlist = pc(query)
        return objlist

    def getRelatedCollectionsMetadata(self, **kw):
        """ Returns catalog objects """
        pc = getToolByName(self, 'portal_catalog')
        uids = self.getRawRelatedCollections()
        query = {'UID':uids}
        query.update(kw)
        objlist = pc(query)
        return objlist

    def combineCollectionLanguage(self):# Languages of subcollections might need to be considered
        """ Returns the list of languages used by resourcs in collection"""
        pc=getToolByName(self, 'portal_catalog')
        languages = {}
        language = 'en'
        objectUIDs = self.getRawRelatedContent() + self.getRawRelatedMethods() + self.getRawRelatedTools()
        objects = pc({'UID':objectUIDs})
        for object in objects:
            # Empty language string gets omited
            if object.Language != '':
                if object.Language not in languages.keys():
                    languages[object.Language] = 1
                else:
                    languages[object.Language] = languages[object.Language] + 1
        if languages:
            sorter = []
            for k in languages.keys():
                sorter.append([languages[k], k])
            sorter.sort(cmp=lambda x,y: cmp(x[0], y[0]))
            sorter.reverse()
            language = sorter[0][1]
        return language


    ################# Embedding collections #################     


    def getRandomObject(self):
        """ Chooses one object to represent the whole collection """
        objectUIDs = self.getRawRelatedContent() + self.getRawRelatedMethods() + self.getRawRelatedTools()
        pc = getToolByName(self, 'portal_catalog')
        results = pc({'UID':objectUIDs, 'getState':['public', 'draft'], 'getHasCoverImage': True})
        if results:
            return random.choice(results).getObject()
        else:
            return None

    def getCollectionInfo(self):
        """ Provides data for embedded collection """
        d={}
        obj=self.getRandomObject()
        if obj:
            d['coverUrl'] = obj.getCoverImageURL()
        else:
            d['coverUrl'] = ''
        d['collectionUrl'] = self.absolute_url()
        pu = getToolByName(self,'portal_url')
        d['listStyle'] = "line-height: 1.5em;margin: 0.5em 0 0 1.5em;padding: 0;list-style-image: url(%s/bullet.gif);list-style-type: square" % pu()
        d['collectionTitle'] = self.Title()
        d['content_n'] = len(self.getResources(reftype='relatedContent', private_materials=False))
        d['methods_n'] = len(self.getRelatedMethods())
        d['tools_n'] = len(self.getRelatedTools())
        d['collections_n'] = len(self.getRawRelatedCollections())
        short_desc=self.getBlurp()
        if short_desc:
            if short_desc.endswith('</p>'):
                short_desc = short_desc[:-4]
            if short_desc.startswith('<p>'):
                short_desc = short_desc[3:]
        d['collectionDescription'] = short_desc or ''
        return d



    ################ Notifications ##############################

    security.declarePrivate('notifyCollectionAdd')
    def notifyCollectionAdd(self, obj):
        lutool = getToolByName(self, 'lemill_usertool')
        auth_mf = lutool.getMemberFolder()
        if obj.Creator() != lutool.getAuthenticatedId() and obj.meta_type in self.getFeaturedTypes():
            mf = lutool.getMemberFolder(obj.Creator())
            # See if notification is checked
            if mf and mf.canNotify('resource_added_to_collection'):
                language=lutool.getCommunicationLanguage(mf)
                dict={'name':to_unicode(auth_mf.getNicename()),
                    'title':to_unicode(obj.Title()),
                    'url':to_unicode(self.absolute_url())}                
                msg = self.translate("%(name)s has added your resource '%(title)s' to a collection: %(url)s",domain="lemill",target_language=language) % dict
                ltool = getToolByName(self, 'lemill_tool')
                ltool.mailNotification(msg=msg, recipient=mf.getEmail(), language=language) 


    ########## Collectiong PDF file generation section ##########

    def isPDFEnabled(self):
        """ Do we want to show link to pdf download? """
        return pdf_enabled

    def downloadPage(self):
        """ Just returns collection_pdf -page. We don't have links to this template to avoid bots"""
        return self.collection_page()


    def downloadPDF(self):
        """ This method is the front-end for pisa, PDF file generator """
        if not pdf_enabled:
            return None
        image_cache={}
        portal=self.portal_url
        portal_url=self.portal_url()

        def getFSSPath(piece, size_name):
            """Get path to actual file"""
            field=piece.getField('image')
            stor=field.getStorage(piece)
            info = stor.getFSSInfo(size_name, piece)    
            if info is None:
                return ''    
            strategy = stor.getStorageStrategy(size_name, piece)
            props = stor.getStorageStrategyProperties(size_name, piece, info)
            path = strategy.getValueFilePath(**props)
            return path


        class Callback(pisa.pisaLinkLoader):
            """ Our own version of pisa's callback method. If links are local, get them from zope and if they use
                FileSystemStorage, point to that file instead of building a temp."""               
            def __del__(self):
                # Please DO NOT remove originals from file system :/
                for path in self.tfileList:
                    if path.split('/')[-1].startswith('pisa-'):
                        os.remove(path)

                    
            def getFileName(self, name, relative=None):
                name=name.replace("\n","")
                name=name.replace(" ", "%20")
                if name.startswith('fonts/'):
                    return os.path.join(TTF_FONTS, name.split('/')[-1])
                if name in image_cache:
                    return image_cache[name]
                url = urlparse.urljoin(relative or self.src, name)
                url_path=url.split('/')
                if url_path[-1] in ['image_large', 'image_small','image_slide'] and url.startswith(portal_url):
                    portal_path=portal_url.split('/')
                    url_path=url_path[len(portal_path):]
                    obj=portal.unrestrictedTraverse(url_path)                    
                    piece=portal.unrestrictedTraverse(url_path[:-1])
                    size_name=url_path[-1]
                    path=getFSSPath(piece, size_name)
                    image_cache[name]=path
                    self.tfileList.append(path)
                    return path
                path = urlparse.urlsplit(url)[2]
                suffix = ""
                if "." in path:
                    new_suffix = "." + path.split(".")[-1].lower()
                    if new_suffix in (".css", ".gif", ".jpg", ".png"):
                        suffix = new_suffix                    
                path = tempfile.mktemp(prefix="pisa-", suffix = suffix)  
                tfile = file(path, "wb")
                if url.startswith(portal_url):
                    portal_path=portal_url.split('/')
                    url_path=url_path[len(portal_path):]
                    obj=portal.unrestrictedTraverse(url_path)                    
                    if hasattr(obj, 'data') and obj.data:
                        data=StringIO(str(obj.data))                  
                    elif hasattr(obj, '_data') and obj._data:
                        data=StringIO(str(obj._data))
                    else:
                        data=StringIO(str(obj))
                    while True:
                        d=data.read(1024)
                        if not d:
                            break
                        tfile.write(d)
                    data.close()
                    tfile.close()
                else:
                    ufile = urllib.urlopen(url)
                    while True:
                        data = ufile.read(1024)
                        if not data:
                            break
                        tfile.write(data)
                    ufile.close()
                    tfile.close()
                self.tfileList.append(path)
                image_cache[name]=path
                return path
        # This is a hack not to get over keyError with 'defavusans' font face
        #pdfmetrics.registerFont(ttfonts.TTFont("DejaVuSans", os.path.join(TTF_FONTS, "DejaVuSans.ttf")))
        filename = ".".join((self.id,'pdf'))
        portal_url=self.portal_url()
        portal=self.portal_url
        result_stringio = StringIO()
        url= '/'.join((self.absolute_url(), 'collection_pdf'))
        source_text=self.collection_pdf()
        pdf = pisa.CreatePDF(
            src=source_text, 
            dest=result_stringio,
            path=url, 
            link_callback=Callback(url).getFileName,
            quiet=True,
            #xhtml=True, 
            #encoding='utf-8', 
            )

        if not pdf.err:
            response = self.REQUEST.RESPONSE
            response.setHeader('Content-Type', 'application/pdf')
            response.setHeader('Content-Disposition', 'attachment; filename=%s' % filename)
            result_stringio.seek(0)
            return result_stringio.read()
        else:
            ltool = getToolByName(self, "lemill_tool")
            ltool.addPortalMessage("A problem occured, PDF could not be generated.", type="stop")
            return self.REQUEST.RESPONSE.redirect(self.absolute_url())
        # removed   <div id="footerContent"><pdf:pagenumber /></div>


#Zip / SCORM download stuff begin --------------------------------------------------------------------------------
    def download(self, PACKAGE_TYPE="HTML"):
        """ Builds a zip. Set PACKAGE_TYPE to SCORM to generate an imsmanifest.xml file. """

        if PACKAGE_TYPE == "PDF":
            return self.downloadPDF()

        elif PACKAGE_TYPE == "PAGE":
            return self.downloadPage()

        else:
            # we'll fix zips and scorms later
            return

        def splitHTML(htmlPage, pageURL):

            def flatten(seq):
                res = []
                for item in seq:
                    if isinstance(item, (list, tuple)):
                        res.extend(flatten(item))
                    else:
                        res.append(item)
                return res

            def combineNones(inputList, infoList):
                previousInfo = ''
                text = ''
                list = range(len(infoList))
                list.reverse()
                for i in list:
                    if infoList[i] == None:
                        if previousInfo == None:
                            text = inputList[i] + text
                        else:
                            previousInfo = None
                            text = inputList[i]
                        del infoList[i]
                        del inputList[i]
                    elif previousInfo == None:
                        previousInfo = ''
                        infoList.insert(i + 1, None)
                        inputList.insert(i + 1, text)
                if previousInfo == None:
                    infoList.insert(0, None)
                    inputList.insert(0, text)

            def recursiveSplit(inputList, infoList, info, reg, first, next, delete = -1):
                if isinstance(inputList, (list, tuple)):
                    for i in range(len(inputList)):
                        if not isinstance(infoList[i], str):
                            inputList[i], infoList[i] = recursiveSplit(inputList[i], infoList[i], info, reg, first, next, delete)
                else:
                    reg = sre.compile(reg, sre.DOTALL | sre.IGNORECASE)
                    inputList = sre.split(reg, inputList)
                    if len(inputList) > 1:
                        infoList = []
                        for i in range(len(inputList)):
                            mod = i % next
                            if mod == first:
                                infoList.append(info)
                            else:
                                if mod == delete:
                                    inputList[i] = ''
                                infoList.append(None)
                        combineNones(inputList, infoList)
                    else:
                        infoList = [infoList]
                return inputList, infoList

            splitHtml, infoList = recursiveSplit(htmlPage, None, 'base', '<base href="(.*?)".*?/>', 1, 2)
            if len(splitHtml) > 1:
                baseURL = splitHtml[-2]
                del splitHtml[1::2]
                del infoList[1::2]
            else:
                baseURL = pageURL
            if not baseURL.endswith('/'):
                baseURL += '/'

            splitHtml, infoList = recursiveSplit(splitHtml, infoList, 'src', '(<link[^>]+href=")(.*?)("[^>]+rel="stylesheet")', 2, 4)
            splitHtml, infoList = recursiveSplit(splitHtml, infoList, 'href', '(<a[^>]+)href="(.*?)"', 2, 3)
            splitHtml, infoList = recursiveSplit(splitHtml, infoList, 'fvars', '(<object.*?<embed[^>]*?src="(mp3player.swf|FlowPlayer.swf|player.swf)"[^>]*?flashvars=")(.*?)(".*?</object>)', 3, 5, 2)
            splitHtml, infoList = recursiveSplit(splitHtml, infoList, 'XMLmp3', '(<voiceover[^>]+src=")(.*?)(")', 2, 4)
            splitHtml, infoList = recursiveSplit(splitHtml, infoList, 'src', '(<[^>]+src=")(.*?)(")', 2, 4)
            splitHtml, infoList = recursiveSplit(splitHtml, infoList, 'src', '(<param.+?name="movie".*?value=")(.*?)(")', 2, 4)
            splitHtml, infoList = recursiveSplit(splitHtml, infoList, 'fvars', r"(<script.*?>.*?AC_FL_RunContent\(.*?'flashvars', ')(.*?)((?<!\\)'.*?</script>)", 2, 4)
            splitHtml, infoList = recursiveSplit(splitHtml, infoList, 'jsfname', "(<script.*?>.*?AC_FL_RunContent\(.*?'movie', ')(.*?)(')", 2, 4)
            splitHtml, infoList = recursiveSplit(splitHtml, infoList, 'fvars', '(<param.+?name="flashvars".*?value=")(.*?)(")', 2, 4)
            return flatten(splitHtml), flatten(infoList), baseURL

        def getAbsoluteURL(url, info, baseURL=''):
            flash = None
            if info in ('src', 'jsfname', 'XMLmp3', 'href'):
                if not url.startswith('http://'):
                    url = baseURL + url
            elif info == 'fvars':
                if url.startswith('file='):
                    url = url[5:-5]
                    flash = 'mp3'
                elif url.startswith('xml='):
                    url = url[4:]
                    flash = 'pilot'
                elif url.startswith("config={videoFile: '"):
                    url = url[20:-2]
                    flash = 'flv1'
                elif url.startswith("config={videoFile: \\'"):
                    url = url[21:-3]
                    flash = 'flv2'
            url = url.replace('\\', '/')
            url = url.replace('at_download/', '')
            return url, flash

        def splitFileName(fileName):
            splitted = fileName.split('.')
            if len(splitted) > 1:
                return '.'.join(splitted[:-1]), '.' + splitted[-1]
            return fileName, ''

        def hasFileNameInSrcs(fileName, srcs):
            for absURL in srcs:
                src = srcs[absURL]
                if src.has_key('fileName') and src['fileName'] == fileName:
                    return src
            return None

        def findUniqueFileName(absURL, srcs):
            fileName = absURL.split('?')[0].split('/')[-1]
            src2 = hasFileNameInSrcs(fileName, srcs)
            if src2 == None:
                return fileName
            else:
                src2['counter'] += 1
                fileName, extension = splitFileName(fileName)
                return findUniqueFileName('%s(%d)%s' % (fileName, src2['counter'], extension), srcs)

        def processHtml(splitHtml, infoList, srcs, hrefs, baseURL, htmlIndex):
            for i in range(len(infoList)):
                if infoList[i] in ('src', 'jsfname', 'fvars', 'XMLmp3', 'href'):
                    absURL, flash = getAbsoluteURL(splitHtml[i], infoList[i], baseURL)
                    if infoList[i] != 'href' or splitHtml[i].find('at_download') != -1:
                        if not absURL.startswith('http://') or absURL.startswith(self.portal_url()):
                            if srcs.has_key(absURL):
                                srcs[absURL]['usedBy'].add(htmlIndex)
                            else:
                                srcs[absURL] = {}
                                src = srcs[absURL]
                                src['fileName'] = findUniqueFileName(absURL, srcs)
                                src['finalURL'] = ''
                                src['usedBy'] = set([htmlIndex])
                                src['counter'] = 0
                                if flash == 'mp3':
                                    src['extension'] = 'mp3'
                                elif flash == 'pilot':
                                    src['extension'] = 'xml'
                                elif flash in ('flv1', 'flv2'):
                                    src['extension'] = 'flv'
                                elif infoList[i] == 'XMLmp3':
                                    src['extension'] = 'mp3'
                                else:
                                    src['extension'] = ''
                        else:
                            infoList[i] = None
                if infoList[i] == 'href':
                    absURL, flash = getAbsoluteURL(splitHtml[i], infoList[i], baseURL)
                    if hrefs.has_key(splitHtml[i]):
                        hrefs[absURL]['usedBy'].add(htmlIndex)
                    else:
                        hrefs[absURL] = {}
                        href = hrefs[absURL]
                        href['finalURL'] = ''
                        href['type'] = 0
                        href['usedBy'] = set([htmlIndex])

        def processPilotXMLs(srcs, baseURLs, baseDirs):
            xmlDatas = {}
            xmlList = [absURL for absURL in srcs if srcs[absURL]['extension'] == 'xml']
            for absURL in xmlList:
                src = srcs[absURL]
                xml = self.aq_parent.restrictedTraverse(absURL.split(self.portal_url() + '/')[1])().decode('utf_16').encode('utf_8')
                xmlDatas[absURL]={}
                xmlData = xmlDatas[absURL]
                xmlData['split'], xmlData['info'], baseURL = splitHTML(xml, '')
                xmlData['fileName'] = src['fileName']
                xmlData['baseDirs'] = []
                for htmlIndex in src['usedBy']:
                    processHtml(xmlData['split'], xmlData['info'], srcs, {}, baseURLs[htmlIndex], htmlIndex)
                    xmlData['baseDirs'].append(baseDirs[htmlIndex])
            return xmlDatas

        def downloadFiles(srcs, zip, baseDirs = []):
            def addExtension(fileName, extension):
                name, ext = splitFileName(fileName)
                if ext == '' and extension != '':
                    fileName = '%s.%s' % (fileName, extension)
                return fileName
            for absURL in srcs:
                src = srcs[absURL]
                data = ''
                mediaType = ''
                subType = ''
                try:
                    if src['extension'] != 'xml':
                        dataObj = self.aq_parent.restrictedTraverse(absURL.split(self.portal_url() + '/')[1].split('?')[0])
                        mediaType, subType = dataObj.getContentType().split('/')
                        subType = subType.split(';')[0]
                        if mediaType == 'image':
                            data = dataObj.data.__str__()
                            if subType in ('jpeg', 'pjpeg'):
                               src['extension'] = 'jpg'
                            elif subType == 'x-ms-bmp':
                               src['extension'] = 'bmp'
                            elif subType in ('png', 'gif'):
                                src['extension'] = subType
                            elif subType == 'x-png':
                                src['extension'] = 'png'
                        else:
                            data = str(dataObj)
                            if mediaType == 'application' and subType == 'x-shockwave-flash':
                                src['extension'] = 'swf'
                            elif mediaType == 'video':
                                if subType in ('x-msvideo', 'avi'):
                                    src['extension'] = 'avi'
                                elif subType == 'x-ms-wmv':
                                    src['extension'] = 'wmv'
                                elif subType == 'mpeg':
                                    src['extension'] = 'mpg'
                                elif subType == 'mp4':
                                    src['extension'] = subType
                                elif subType == 'quicktime':
                                    src['extension'] = 'mov'
                            elif mediaType == 'audio' and subType == 'mpeg':
                                src['extension'] = 'mp3'
                except (AttributeError):
                    # restrictedTraverse error, see if that can be one of the special cases of internal images
                    # Let us try to read the file and see if that can be our case
                    try:
                        portal_url = getToolByName(self, 'portal_url')
                        portal_url = portal_url()
                        import urllib2
                        # If this is our own object, we try to deal with it (might be unneeded, but let's play it safe)
                        if absURL.lower().startswith(portal_url):
                            # getting the file data behind url, then reading the file data
                            dataObj = urllib2.urlopen(absURL)
                            data = dataObj.read()
                            # we don't really need mediaType here, just need to know the file extension
                            # mostly this should handle cases of system internal images
                            subType = absURL.split('/')[-1:][0].split('.')[-1:][0]
                            src['extension'] = subType
                        else:
                            # This is not one of our urls, so we do nothing to handle the situation
                            print "restrictedTraverse error: " + absURL
                    except (AttributeError):
                        # This is not one of our special cases that we can handle
                        print "restrictedTraverse error: " + absURL

                fileName = addExtension(src['fileName'], src['extension'])
                src['finalURL'] = '_Files/' + fileName
                if src['extension'] != 'xml':
                    for i in src['usedBy']:
                        zip.writestr(baseDirs[i] + src['finalURL'], data)

        def processHrefs(hrefs, srcs, htmlURLs, baseDirs, portalURL):
            def checkURLCases(absURL, portalURL):
                #Might need to import these from some more general place
                places = ['/content/pieces/', '/content/references/', '/content/printresources/', '/content/lessonplans/', '/content/pilots/', '/content/presentations/', '/content/schoolprojects/', '/content/webpages/', '/content/exercises/'] + ['/methods/', '/tools/']
                for place in places:
                    if absURL.count(portalURL + place) > 0:
                        return True
                return False
            downloadURLs = []
            for absURL in srcs:
                fileName = absURL.split('?')[0].split('/')
                domain = '/'.join(fileName[:-1])
                fileName = fileName[-1]
                downloadURLs.append('%s/at_download/%s' % (domain, fileName))
            for absURL in hrefs:
                href = hrefs[absURL]
                if absURL in htmlURLs:
                    href['finalURL'] = 'href="%sindex.html"' % baseDirs[htmlURLs.index(absURL)]
                elif absURL + '/' in htmlURLs:
                    href['finalURL'] = 'href="%sindex.html"' % baseDirs[htmlURLs.index(absURL + '/')]
                elif absURL in srcs:
                    href['finalURL'] = srcs[absURL]['finalURL']
                    href['type'] = 1
                elif absURL in downloadURLs:
                    href['finalURL'] = srcs[absURL.replace('/at_download', '')]['finalURL']
                    href['type'] = 1
                elif absURL.startswith(portalURL) and not (absURL.endswith('/CollectionRSS') or checkURLCases(absURL, portalURL)):
                    href['finalURL'] = ''
                else:
                    href['finalURL'] = 'href="%s"' % absURL

        def updateHtmls(splitHtmls, infoLists, baseURLs, baseDirs, srcs, hrefs):
            for i in range(len(splitHtmls)):
                splitHtml = splitHtmls[i]
                infoList = infoLists[i]
                for j in range(len(splitHtml)):
                    if infoList[j] in ('src', 'jsfname', 'fvars'):
                        absURL, flash = getAbsoluteURL(splitHtml[j], infoList[j], baseURLs[i])
                        src = srcs[absURL]
                        finalURL = src['finalURL']
                        if infoList[j] == 'src':
                            splitHtml[j] = finalURL
                        elif infoList[j] == 'jsfname':
                            splitHtml[j] = finalURL
                        elif infoList[j] == 'fvars':
                            if flash == 'mp3':
                                splitHtml[j] = 'file=%s' % finalURL
                            elif flash == 'pilot':
                                splitHtml[j] = 'xml=%s' % finalURL
                            elif flash == 'flv1':
                                splitHtml[j] = "config={videoFile: '../%s'}" % finalURL
                            elif flash == 'flv2':
                                splitHtml[j] = "config={videoFile: \\'../%s\\'}" % finalURL
                    elif infoList[j] == 'href':
                        absURL, flash = getAbsoluteURL(splitHtml[j], infoList[j], baseURLs[i])
                        href = hrefs[absURL]
                        if href['type'] == 1:
                            finalURL = 'href="%s"' % href['finalURL']
                        else:
                            finalURL = href['finalURL']
                        splitHtml[j] = finalURL

        def updatePilotXMLs(xmlDatas, baseURLs, srcs):
            for absURL in xmlDatas:
                splitXML = xmlDatas[absURL]['split']
                xmlInfoList = xmlDatas[absURL]['info']
                for j in range(len(splitXML)):
                    if xmlInfoList[j] in ('src', 'XMLmp3'):
                        absURL2, flash = getAbsoluteURL(splitXML[j], xmlInfoList[j])
                        src = srcs[absURL2]
                        splitXML[j] = src['finalURL']

        def addHtmlsToZip(splitHtmls, zip, baseDirs = None):
            i = 0
            baseDir = ''
            for splitHtml in splitHtmls:
                if isinstance(baseDirs, (list, tuple)):
                    baseDir = baseDirs[i]
                zip.writestr(baseDir + 'index.html', ''.join(splitHtml))
                i += 1

        def addPilotXMLsToZip(xmlDatas, srcs, zip):
            for absURL in xmlDatas:
                xmlData = xmlDatas[absURL]
                xml = ''.join(xmlData['split'])
                for baseDir in xmlData['baseDirs']:
                    zip.writestr(baseDir + srcs[absURL]['finalURL'], xml.decode('utf_8').encode('utf_16'))
                    break

        def addSCORMFiles(version, htmlList, srcs, zip):
            def addMetadata(manifest, obj, tabs):
                language = obj.Language()
                if language == '':
                    language = 'en'
                tab_str=''.join(['\t']*tabs)                    
                manifest.append(''.join((tab_str,'<metadata>')))
                manifest.append(''.join((tab_str,'\t<schema>ADL SCORM</schema>')))
                manifest.append(''.join((tab_str,'\t<schemaversion>1.2</schemaversion>')))
                manifest.append(''.join((tab_str,'\t<imsmd:lom>')))
                manifest.append(''.join((tab_str,'\t\t<general>')))
                manifest.append(''.join((tab_str,'\t\t\t<title>')))
                manifest.append(''.join((tab_str,'\t\t\t\t<langstring xml:lang="',language,'">',obj.TitleOrId(),'</langstring>')))
                manifest.append(''.join((tab_str,'\t\t\t</title>')))
                manifest.append(''.join((tab_str,'\t\t\t<language>',language,'</language>')))
                tags = obj.getTags()
                for tag in tags:
                    manifest.append(''.join((tab_str,'\t\t\t<keyword>')))
                    manifest.append(''.join((tab_str,'\t\t\t\t<langstring xml:lang="',language,'">',tag,'</langstring>')))
                    manifest.append(''.join((tab_str,'\t\t\t</keyword>')))
                manifest.append(''.join((tab_str,'\t\t</general>')))
                manifest.append(''.join((tab_str,'\t\t<lifecycle>')))
                manifest.append(''.join((tab_str,'\t\t\t<version>')))
                manifest.append(''.join((tab_str,'\t\t\t\t<langstring xml:lang="',language,'">',str(obj.getLatestEditDate()),'</langstring>')))
                manifest.append(''.join((tab_str,'\t\t\t</version>')))
                manifest.append(''.join((tab_str,'\t\t</lifecycle>')))
                manifest.append(''.join((tab_str,'\t</imsmd:lom>')))
                manifest.append(''.join((tab_str,'</metadata>')))
                return manifest

            manifest=[]
            manifest.append('<?xml version="1.0" encoding="utf-8"?>')
            manifest.append('<manifest identifier="%s" version="%s" xmlns="http://www.imsproject.org/xsd/imscp_rootv1p1p2" xmlns:imsmd="http://www.imsglobal.org/xsd/imsmd_rootv1p2p1" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:adlcp="http://www.adlnet.org/xsd/adlcp_rootv1p2" xsi:schemaLocation="http://www.imsproject.org/xsd/imscp_rootv1p1p2 imscp_rootv1p1p2.xsd http://www.imsglobal.org/xsd/imsmd_rootv1p2p1 imsmd_rootv1p2p1.xsd http://www.adlnet.org/xsd/adlcp_rootv1p2 adlcp_rootv1p2.xsd">' % (htmlList[0][0].getId(), version))
            manifest = addMetadata(manifest, self, 1)
            manifest.append('\t<organizations default="ORGANIZATION_%s">' % htmlList[0][0].getId())
            manifest.append('\t\t<title>%s</title>' % htmlList[0][0].TitleOrId())
            manifest.append('\t\t<organization identifier="ORGANIZATION_%s" structure="linear">' % htmlList[0][0].getId())
            for obj in htmlList:
                manifest.append('\t\t\t<item identifier="ITEM_%s" identifierref="RESOURCE_%s" isvisible="true">' % (obj[0].getId(), obj[0].getId()))
                manifest.append('\t\t\t\t<title>%s</title>' % obj[0].TitleOrId())
                manifest = addMetadata(manifest, obj[0], 4)
                manifest.append('\t\t\t</item>')
            manifest.append('\t\t</organization>')
            manifest.append('\t</organizations>')
            manifest.append('\t<resources>')
            for i in range(len(htmlList)):
                manifest.append('\t\t<resource identifier="RESOURCE_%s" type="webcontent" adlcp:scormtype="sco" href="%sindex.html">' % (htmlList[i][0].getId(), htmlList[i][1]))
                manifest.append('\t\t\t<file href="%sindex.html" />' % htmlList[i][1])
                for absURL in srcs:
                    src = srcs[absURL]
                    if i in src['usedBy']:
                        finalURL = htmlList[i][1] + src['finalURL']
                        manifest.append('\t\t\t<file href="%s" />' % finalURL)
                manifest.append('\t\t</resource>')
            manifest.append('\t</resources>')
            manifest.append('</manifest>')
            zip.writestr('imsmanifest.xml', '\n'.join(manifest))
            for file in ('adlcp_rootv1p2.xsd', 'ims_xml.xsd', 'imscp_rootv1p1p2.xsd', 'imsmd_rootv1p2p1.xsd'):
                f = open(REPOSITORY + file, 'r')
                zip.writestr(file, f.read())
                f.close()

        splitHtmls = []
        infoLists = []
        baseURLs = []
        baseDirs = []
        htmlURLs = []
        srcs = {}
        hrefs = {}
        times = []
        htmlList = [(self, '')]
        htmlIndex = 0
        #XXX This one could be moving in from some differet place, so that we would not forget to update it when new types get created
        content_subtypes = {'Piece':'pieces','LeMillReference':'references','PresentationMaterial':'presentations','PILOTMaterial':'pilots','MultimediaMaterial':'webpages','ExerciseMaterial':'exercises','LessonPlan':'lessonplans','SchoolProjectMaterial':'schoolprojects','LeMillPrintResource':'printresources'}
        for resourceType in ('Content', 'Methods', 'Tools'):
            for resource in self.getResources(reftype = 'related' + resourceType):
                if resourceType == 'Content':
                    if resource.meta_type in content_subtypes.keys():
                        htmlList.append((resource, '/'.join((resourceType.lower(), content_subtypes[resource.meta_type], resource.getId(),''))))
                else:
                    htmlList.append((resource, '/'.join((resourceType.lower(), resource.getId(),''))))
                times.append(resource.getLatestEditDate())

        for html in htmlList:
            splitHtml, infoList, baseURL = splitHTML(html[0].standalone_view(), self.absolute_url())
            splitHtmls.append(splitHtml)
            infoLists.append(infoList)
            baseURLs.append(baseURL)
            baseDirs.append(html[1])
            htmlURLs.append('/'.join((self.absolute_url(), html[1])))
            processHtml(splitHtml, infoList, srcs, hrefs, baseURL, htmlIndex)
            htmlIndex += 1

        xmlDatas = processPilotXMLs(srcs, baseURLs, baseDirs)
        zipStr = StringIO()
        zip = zipfile.ZipFile(zipStr, 'w', compression = zipfile.ZIP_DEFLATED)
        downloadFiles(srcs, zip, baseDirs)
        processHrefs(hrefs, srcs, htmlURLs, baseDirs, self.portal_url())
        updateHtmls(splitHtmls, infoLists, baseURLs, baseDirs, srcs, hrefs)
        updatePilotXMLs(xmlDatas, baseURLs, srcs)
        addHtmlsToZip(splitHtmls, zip, baseDirs)
        addPilotXMLsToZip(xmlDatas, srcs, zip)
        if PACKAGE_TYPE == 'SCORM':
            addSCORMFiles(str(max(times)), htmlList, srcs, zip)
        zip.close()
        response = self.REQUEST.RESPONSE
        response.setHeader('Content-Type', 'application/zip')
        response.setHeader('Content-Disposition', 'attachment; filename="%s.zip"' % self.getId())
        return zipStr.getvalue()
#Zip / SCORM download sruff end ----------------------------------------------------------------------------------


registerType(Collection, PROJECTNAME)

class CollectionsFolder(LeMillFolder, BaseFolder):
    """ container for collection """
    schema = BaseSchema
    id = "collections"
    meta_type = "CollectionsFolder"
    archetype_name = "CollectionsFolder"  

    actions= (
    {
    'id':'view',
    'name':'view',
    'action':'string:${object_url}/collections_list',
    'permission':('View',),
    },
    )

    aliases = {
        '(Default)' : 'collections_list',
        'view'      : 'collections_list',
        'edit'      : 'collections_list'
    }
                
registerType(CollectionsFolder, PROJECTNAME)