source: trunk/Collection.py @ 495

# 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.public import BaseContent, registerType, BaseFolder
from Products.Archetypes.public import StringField
from Products.Archetypes.public import TextAreaWidget
from Products.Archetypes.atapi import DisplayList
from Globals import InitializeClass
from Products.CMFCore.utils import getToolByName
from AccessControl import ClassSecurityInfo, Unauthorized
from config import PROJECTNAME, ALL_CONTENT_TYPES, CONTENT_TYPES

schema = BaseSchema + Schema((

    StringField('description',
    widget=TextAreaWidget(
        label="Description",
        description="",
        label_msgid='label_description',
        description_msgid='description_description',
        visible={'view':'invisible','edit':'visible'},
        ),
    ),
    
    ReferenceField('refsToResources',
        accessor = 'getRefsToResources',
        relationship = 'References',
        mutator = 'addRefsToResources',
        allowed_types = ALL_CONTENT_TYPES, 
        multiValued = True,
        widget = ReferenceBrowserWidget(
            visible = {'view':'invisible', 'edit':'invisible'},
            ),
    ),
))

class Collection(BaseContent):
    """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
    _at_rename_after_creation = True


    def at_post_create_script(self):
        self.at_post_edit_script()

    def at_post_edit_script(self):
        self._renameAfterCreation()

    def after_add_rename(self):
        self._renameAfterCreation()


    def addRefsToResources(self, ref):
        """ add reference to resource """
        field = self.Schema().get('refsToResources')
        prev = field.getRaw(self, aslist=True)
        new_value = []
        from types import ListType, TupleType
        if type(ref) == ListType or type(ref) == TupleType:
            new_value = prev
            for x in ref:
                new_value.append(x)
        else:
            new_value = prev+[ref,]
        field.set(self, new_value)

    def getItemCount(self):
        """ return how many items are in collection """
        return len(self.getRefsToResources())

    def getResources(self):
        """ ... """
        return self.getRefsToResources()

    def delResources(self, REQUEST):
        """ delete selected resource """
        field = self.Schema().get('refsToResources')
        prev = field.getRaw(self, aslist=True)
        counter = 1
        new = []
        for x in prev:
            if REQUEST.get(str(counter)) != "True":
                new.append(x)
            counter = counter + 1
        field.set(self, new)

    def moveUpResources(self, REQUEST):
        """ move up """
        id = int(REQUEST.get("id"))-1
        field = self.Schema().get('refsToResources')
        prev = field.getRaw(self, aslist=True)
        new = []
        for x in prev:
            new.append(x)
        if id > 0:
           temp = new[id-1]
           new[id-1] = new[id]
           new[id] = temp
        field.set(self, new)

    def moveDownResources(self, REQUEST):
        """ move down """
        id = int(REQUEST.get("id"))-1
        field = self.Schema().get('refsToResources')
        prev = field.getRaw(self, aslist=True)
        new = []
        counter = 0
        for x in prev:
            new.append(x)
            counter = counter + 1
        if id < counter-1:
           temp = new[id+1]
           new[id+1] = new[id]
           new[id] = temp
        field.set(self, new)

    def isReadyForStory(self):
        """ returns true or false. Write a story button appears only when
        there is at least one object from each three sections """
        has_content = 0
        has_act = 0
        has_tool = 0
        for x in self.getRefsToResources():
            if x.meta_type in CONTENT_TYPES: has_content = 1
            if x.meta_type == 'Activity': has_act = 1
            if x.meta_type == 'Tool': has_tool = 1
        if 1 == has_content == has_act == has_tool:
            return True
        return False

    def amIOwner(self):
        """ check owner of object """
        return self.whoami() == str(self.getOwner())

    def manage_afterAdd(self, item, container):
        """Replaces the left side portlets with the content type's own action portlet."""
        BaseContent.manage_afterAdd(self, item, container)
        if not hasattr(item.aq_base, 'left_slots'):
            self._setProperty('left_slots', ['here/portlet_%s_actions/macros/portlet' % item.meta_type.lower(),], 'lines')

registerType(Collection, PROJECTNAME)

class CollectionsFolder(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',),
    },
    )

    def getCollections(self, obj_uid=None):
        """ return a list of user's collections.
            When REQUEST.obj_uid is set filter collections where object is used
            XXX: maybe this can be done in more elegant way
        """
        res = []
        if obj_uid is None:
            return self.objectValues('Collection')
        q = { 'targetUID': obj_uid }
        qres = self.reference_catalog(q)
        for q in qres:
            v = self.reference_catalog.lookupObject(q.UID)
            source = v.getSourceObject()
            if source.meta_type == 'Collection':
                res.append(source)
        return res

registerType(CollectionsFolder, PROJECTNAME)