root/trunk/BlogPost.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.public import BaseSchema, BaseContent, registerType
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, MODIFY_CONTENT, VIEW
from CommonMixIn import CommonMixIn
from Schemata import coverImage, latest_edit_schema, score, state
from Products.Archetypes.atapi import DisplayList
from FieldsWidgets import TagsField, TagsWidget, LeStringWidget, LeTextAreaWidget, WYSIWYMField, AuthorsWidget
from permissions import ModerateContent, MODIFY_CONTENT, ACCESS_CONTENT, VIEW
from DateTime import DateTime
from GroupBlog import GroupBlog
from Discussable import Discussable

# Same thing as with MemberFolder but easier: MemberBlogs contain the values of groups itself in indexable storage.

schema = BaseSchema + coverImage + latest_edit_schema + score +  state + Schema((
    StringField(
        name='title',
        required=1,
        searchable=1,
        default='',
        accessor='Title',
        widget=LeStringWidget(
            label='Topic',
            label_msgid='label_topic',
            visible={'view' : 'invisible'},
            i18n_domain='lemill',
        ),
    ),
    StringField(
        name='parentBlog',
        index='FieldIndex:schema',
        widget=ComputedWidget(
            visible={'edit':'invisible', 'view':'invisible'}
            ),
        ),        
    WYSIWYMField('bodyText',
        accessor="getBodyText",
        mutator = "setBodyText",
        edit_accessor = 'getRawBodyText',
        index='ZCTextIndex',
        copied_in_translation=True,
        searchable = True,
        required = True,
        widget=LeTextAreaWidget(
            label="Body text",
            label_msgid="label_wysiwym_body_text",
            i18n_domain="lemill",
            rows=10
            ),
        ),
))

class BlogPost(Discussable, CommonMixIn, BaseContent):
    """Blog post"""

    meta_type = "BlogPost"
    archetype_name = "BlogPost"
    allow_discussion = True
    _at_rename_after_creation = True

    security = ClassSecurityInfo()
    default_view = ('blogpost_view')
    security.declareObjectPublic()
    schema = schema
    portlet = 'here/portlet_blogpost_actions/macros/portlet'

    security.declarePrivate('at_post_edit_script')
    def at_post_edit_script(self):
        """ Rename id to resemble title, add to list of collaboration proposals of community if such, and add to recent posts of blog. """
        old=self.getId()
        self._renameAfterCreation()
        new=self.getId()
        if old != new: # new id is updated to recent posts list
            try: # if for some reason posts are not inside blogs
                blog=self.getBlog()
                blog.replaceRecent_post(old, new) 
            except:
                pass

    security.declarePrivate('at_post_create_script')
    def at_post_create_script(self):
        """ Add to blog's recent posts, notify group founder, enable syndication """
        blog = self.getBlog()
        if blog:
            blog.addRecent_post(self.getId())
            self.setParentBlog(blog.id)
            blog.notifyNewThread()
        syn_tool = getToolByName(self, 'portal_syndication', None)
        if not syn_tool.isSyndicationAllowed(self):
            try:
                syn_tool.enableSyndication(self)
            except AttributeError:
                pass
        self.reindexObject() # parentBlog does not get indexed unless we do this. 

    def setPermissions(self):
        self.manage_permission(VIEW, ('Manager','Owner','Member','Authenticated','Anonymous'), acquire=0)
        self.manage_permission(MODIFY_CONTENT, ('Manager','Owner'), acquire=0)
        self.manage_permission(ModerateContent, ('Manager','Owner','Reviewer'), acquire=0)
        self.manage_permission(ACCESS_CONTENT, ('Manager','Owner','Member','Authenticated','Anonymous'), acquire=0)
                
    def getAuthors(self):
        """Emulate the method that Resource has"""
        return [self.Creator(),]

    def getCreatorsString(self, as_links=True):
        """ Emulate similar method from Resources, used by document_byline.pt """
        values=self.getAuthors()
        utool=getToolByName(self, 'lemill_usertool')
        if values[0]=='*!*':
            values=values[1:]  
        names=[utool.linkTo(user_id, disabled=not as_links) for user_id in values] 
        return ", ".join(names)

    def getCoverImageURL(self):
        """BlogPosts shouldn't have their own cover images -- returns authors portrait."""
        lutool=getToolByName(self, 'lemill_usertool')
        return lutool.getMemberPortrait(self.Creator())        

    def getDiscussionURL(self):
        """ Overrides Discussable's method """
        return self.absolute_url()

    def getMetaDescription(self):
        """ Description for html header. """ 
        desc=self.getRawBodyText()
        desc_len=0
        desc_result=[]
        ltool = getToolByName(self, 'lemill_tool')        
        desc=ltool.stripHTML(desc)
        # Add paragraphs until total is over 140 characters
        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)
    
        
    def getNicename(self):
        """ I don't think this will get called but just to make sure. """
        return self.Title()

    def isPost(self):
        return True

    def notifyResourceDiscussed(self):
        """ overload method from Discussable -- do not alert "resource owner" about replies """
        pass

    def canIEdit(self, member=None):
        return self.amIOwner() or self.canIModerate()

    security.declareProtected(ModerateContent, 'delete_post')
    def delete_post(self):
        """ Hide, remove from recent posts and remove from Collaboration proposals """
        REQUEST = self.REQUEST
        container=self.getBlog()
        uid=self.UID()
        self.setState('deleted')
        self.reindexObject()
        if hasattr(container, 'recent_posts'):
            container.removeRecent_post(self.getId())
        return REQUEST.RESPONSE.redirect(container.absolute_url())

    security.declareProtected(ModerateContent, 'undelete_post')
    def undelete_post(self):
        """ Bring back post but currently doesn't add to collaboration proposals or recent posts """
        REQUEST = self.REQUEST
        container=self.getBlog()
        uid=self.UID()
        self.setState('public')
        self.reindexObject()
        if hasattr(container, 'recent_posts'):
            container.addRecent_post(self.getId())
        return REQUEST.RESPONSE.redirect(self.absolute_url())
    
    def Description(self):
        """ Redirect to full body text """
        return self.getBodyText()
    
    def getDefaultIcon(self, meta_type='', obj=None):
        """ blogposts return creator's portrait """
        lutool=getToolByName(self, 'lemill_usertool')
        return lutool.getMemberPortrait(self.Creator())        

    def getLatestEditDate(self):
        """ Returns creation date as blog posts do not have History """
        return DateTime(self.CreationDate())

    def getLastEditor(self):
        """ Returns id of the Creator """
        return self.Creator()
    

    def getPortletDetails(self, REQUEST, isAnon, member):
        """ Return an object of booleans to determine what to show and what to hide in portlet view """

        v={'groupURL':'',
            'groupCoverImageURL':'',
            'groupTitle':'',
            'editPost':False,
            'deletePost':False,
            'undeletePost':False,
        }
        
        canEdit= self.canIEdit(member)
        isDeleted = self.isDeleted()
        # If resource is not assigned to any group, use the unassigned_discussions instead
        try:
            groupblog=self.getBlog()
        except:
            groupblog=self.community.groups.unassigned_discussions
        if groupblog.id!='unassigned_discussions' and not groupblog.isDeleted():
            v['groupURL']=groupblog.absolute_url()
            v['groupCoverImageURL']=groupblog.getCoverImageURL()
            v['groupTitle']=groupblog.title_or_id()
        

        v['editPost'] = canEdit and not isDeleted
        v['deletePost'] = canEdit and not isDeleted
        v['undeletePost'] = canEdit and isDeleted        
        return v


registerType(BlogPost, PROJECTNAME)