root/trunk/Discussable.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 registerType
from AccessControl import ClassSecurityInfo
from Globals import InitializeClass, Persistent, PersistentMapping
from permissions import ADD_CONTENT_PERMISSION, ModerateContent
from Products.CMFCore.utils import getToolByName
from OFS.SimpleItem import SimpleItem
from DateTime.DateTime import DateTime
from Acquisition import Implicit, aq_base, aq_inner, aq_parent
from OFS.Traversable import Traversable
from config import to_unicode



class Discussable:
    """Mix-in class for enabling comments"""

    security = ClassSecurityInfo()

    def isDiscussable(self):
        """ yes we are """
        return True

    def getDiscussion(self, do_create=True):
        """ Returns dictionary of discussion items """
        talkback=getattr(self.aq_base, 'talkback', None)
        if not talkback:
            if do_create:
                self.talkback=DiscussionContainer()
            else:
                return {}
        elif not isinstance(self.talkback, DiscussionContainer):
            self_destruct=self.convertPloneCommentsToLeMill()
            # This blogpost has had its comments moved to a resource and it has been deleted 
            if self_destruct:
                return {}
        return self.talkback.get()

    def getSortedDiscussion(self):
        """ Returns a list of discussion items sorted by their timecode """
        talkback=self.getDiscussion()
        return [value for key,value in sorted(talkback.items())]

    def postCount(self):
        """ Returns n of comments (CATALOG METADATA) """
        return len(self.getDiscussion())

    def getDiscussionURL(self):
        """ Returns url for page that displays comments """
        return self.absolute_url()+'/view'

    def getCommentURL(self, comment_id):
        """ Returns url for a certain comment id, validates if it looks proper """
        if comment_id.isdigit():
            return '#'.join((self.getDiscussionURL(), comment_id))
        else:
            return self.getDiscussionURL()

    def getLastComment(self):
        """Returns the latest comment"""
        comments=self.getSortedDiscussion()
        if comments:                
            return comments[-1]

    def getLastCommentDate(self):
        """ Returns either date of last comment or modification time (CATALOG METADATA)"""
        last=self.getLastComment()
        edit_date = self.getLatestEditDate()
        if last:
            if last.CreationDate()>edit_date:
                return last.CreationDate()
        return edit_date

    def getTimeToLastComment(self, seconds=False):
        """ Return time to latest comment in dictionary of days, hours, minutes (or seconds for sorting) """        
        letool=getToolByName(self,'lemill_tool')
        return letool.getTimeDifference(self.getLastCommentDate(), seconds)

    # form: discussion.pt
    security.declareProtected(ADD_CONTENT_PERMISSION, 'createReplyFromForm')
    def createReplyFromForm(self, REQUEST):
        """ Get message from a reply form and create it """
        message=REQUEST.get('body_text', '')
        if not message:
            return
        author=getToolByName(self, 'lemill_usertool').getAuthenticatedId()
        date = DateTime().timeTime()
        self.addReply(message, author, date)
        if author!=self.Creator():
            self.notifyResourceDiscussed()
        self.reindexObject()
        return REQUEST.RESPONSE.redirect(self.getCommentURL(str(int(date))))

        
    security.declareProtected(ADD_CONTENT_PERMISSION, 'addReply')
    def addReply(self, message, author, date):
        """ Create a new discussion item and add it to list """
        reply=DiscussionObject(message, author, date, parent=self)
        key=reply.getId()
        self.talkback.set(key, reply)
    
    security.declarePrivate('_deleteReply')
    def _deleteReply(self, key):
        self.talkback.delete(key)

    # form: discussion.pt
    security.declareProtected(ModerateContent, 'deleteReplyFromForm')
    def deleteReplyFromForm(self, REQUEST):
        """ handles deletion requests """
        id=REQUEST.get('delete_id', '')
        if id:
            self._deleteReply(id)
        return REQUEST.RESPONSE.redirect(self.getDiscussionURL())

    ################# RSS ######################################
    # currently not used
    def getRSSResults(self,max=30):
        """ Return discussion comments, metadata returned:
        'getURL', 'getLatestEdit', 'Title', 'listCreators','Rights' """
        results=[]
        url_base=self.getDiscussionURL() 
        title='re:%s' % self.Title()                
        for reply in self.getSortedDiscussion()[:max]:
            r_dict={'getURL':'#'.join((url_base, reply.id)), 'getLatestEdit':reply.created, 'Title':title, 'listCreators':[reply.Creator()],'Rights':'CC-SA 2.5'}
            results.append(r_dict)
        return results


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

    # remember to suppress this for blogposts
    security.declarePrivate('notifyResourceDiscussed')
    def notifyResourceDiscussed(self):
        lutool = getToolByName(self, 'lemill_usertool')
        auth_mf = lutool.getMemberFolder()
        mf = lutool.getMemberFolder(self.Creator())
        if mf and mf.canNotify('resource_discussion_note'):
            language=lutool.getCommunicationLanguage(mf)
            dict={'name':to_unicode(auth_mf.getNicename()),
                'title':to_unicode(self.Title()),
                'url':to_unicode('%s/discussion' % self.absolute_url())}                
            msg = self.translate("%(name)s has wrote a discussion note about your resource '%(title)s': %(url)s", domain="lemill", target_language=language) % dict
            ltool = getToolByName(self, 'lemill_tool')
            ltool.mailNotification(msg, recipient=mf.getEmail(), language=language)    


    security.declarePrivate('notifyNewReply')
    def notifyNewReply(self):
        lutool = getToolByName(self, 'lemill_usertool')
        auth_mf = lutool.getMemberFolder()
        # This announcement can have multiple recipients
        replies = context.getComments().values()
        # Get all individuals to post in the thread
        posters=set([r.Creator() for r in replies])
        posters.remove(lutool.getAuthenticatedId())
        if self.Creator() != lutool.getAuthenticatedId():
            posters.add(self.Creator())
        posters = [lutool.getMemberFolder(p) for p in posters]
        # Check if the email sending is enabled
        for recip in [p for p in posters if p and p.canNotify('group_message_posted')]:
            language=lutool.getCommunicationLanguage(mf)
            ltool = getToolByName(self, 'lemill_tool')
            dict={'name':to_unicode(auth_mf.getNicename()),
                'title':to_unicode(self.Title()),
                'url':to_unicode(self.absolute_url())}                
            msg = self.translate("%(name)s has posted a message in your group forum '%(title)s': %(url)s",domain="lemill",target_language=language) % dict
            ltool.mailNotification(msg=msg, recipient=recip.getEmail(), language=language) 


    ######### Migration ###############################

    security.declarePrivate('convertPloneCommentsToLeMill')
    def convertPloneCommentsToLeMill(self):
        print 'converting DiscussionTool comments to LeMill at %s' % self.getId()
        dtool=getToolByName(self, 'portal_discussion')
        rc=getToolByName(self, 'reference_catalog')
        results=rc({ 'sourceUID': self.UID(), 'relationship': 'is_discussion_about' })
        resource=None
        self_destruct=False
        if results:
            try:
                resource=results[0].getObject().getTargetObject()
            except:
                pass
        if resource:
            new_talkback=getattr(resource.aq_base, 'talkback', DiscussionContainer())
            print "Moving comments to resource '%s' (%s)" % (resource.getId(), resource.portal_type) 
            self.talkback=DiscussionContainer()
            self_destruct=True  
        else:
            new_talkback=DiscussionContainer()
            resource=self
        discussion=dtool.getDiscussionFor(self)
        keys=[]
        print discussion.objectIds()
        for key, disc_item in discussion.objectItems():
            new_id=str(key)
            message=disc_item.text
            date=disc_item.creation_date
            timetime=date.timeTime()
            author=disc_item.listCreators()[0]
            new_object=DiscussionObject(message, author, timetime, parent=resource)
            new_object.id=new_id
            new_talkback.set(new_id, new_object)
            print 'adding %s to %s' % (new_object, new_id) 
            keys.append(key)
            
        if len(new_talkback._container)<len(discussion._container):
            raise 'New talkback is missing comments!'
        for key in keys:
            discussion.deleteReply(key)
        resource.talkback=new_talkback
             
        if self_destruct:
            blog=self.aq_parent
            if hasattr(blog, 'recent_posts'):
                blog.removeRecent_post(self.getId())
            blog.manage_delObjects([self.getId()])
        return self_destruct


############ DiscussionContainer, gives a persistent folder-like storage for discussion objects ##############

class DiscussionContainer( Persistent, Implicit, Traversable ):
    """ Holds discussionobjects """

    security = ClassSecurityInfo()

    def __init__(self):
        self.id = 'talkback'
        self._container = PersistentMapping()

    #security.declareProtected(View, 'getId')
    def getId( self ):
        return self.id

    def get(self,key=None, else_value=None):
        if not key:
            return self._container
        else:
            return getattr(self._container, key, else_value)

    def set(self, key, value):
        self._container[key]=value
        
    def delete(self, key):
        del self._container[key]

############### DiscussionObjects are single comments ################
         
class DiscussionObject(SimpleItem):
    """ Comment object """
    security = ClassSecurityInfo()
    portal_type="Discussion Object"

    def __init__(self, message='', author='', date='', parent=None):
        self.id=str(int(date))
        self.setBody(message, parent)
        lutool=getToolByName(parent, 'lemill_usertool')
        self.creators = [author or lutool.getAuthenticatedId()]
        now = DateTime()
        if date and not isinstance( date, DateTime ):
            date=DateTime(date)
        self.creation_date = date or now
        self.modification_date = date or now
        self.created=date or now        
        
    def Creator(self):
        """ Public access to creator """
        return self.creators and self.creators[0] or '' 
        
    def getBodyText(self):
        """ Comment body, parsed """
        return self.bodyText

    def getRawBodyText(self):
        """ Comment body, raw """
        return self.rawBodyText

    def setBody(self, message, parent=None):        
        lt=getToolByName(parent or self, 'lemill_tool')
        self.rawBodyText=message
        self.bodyText=lt.parse_text(message)

    def CreationDate(self):
        """ Public access to date """
        return self.creation_date

    def RSSDate(self):
        """ In HTML4-format for RSS-feed """
        return self.creation_date.HTML4()
        
InitializeClass(Discussable)