root/trunk/GroupBlog.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.CMFCore.permissions import ModifyPortalContent
from Products.Archetypes.public import BaseFolder, BaseFolderSchema, registerType
from Products.Archetypes.atapi import DisplayList
from Globals import InitializeClass
from Products.CMFCore.utils import getToolByName
from AccessControl import ClassSecurityInfo, Unauthorized
from messagefactory_ import i18nme as _
from LargeSectionFolder import LeMillFolder
from Products.CMFPlone.PloneBatch import Batch

from config import PROJECTNAME, MODIFY_CONTENT, VIEW, DEFAULT_ICONS, MATERIAL_TYPES, to_unicode, LANGUAGES
from permissions import MODIFY_CONTENT
from Schemata import tags, coverImage, deletionReason, score, subject_area_schema, latest_edit_schema, state
from CommonMixIn import CommonMixIn
from FieldsWidgets import WYSIWYMField, LeVisualWidget

from DateTime import DateTime
import random, time

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

groupblog_schema = Schema((
    StringField('title',
        required=True,
        searchable = True,
    ),
    WYSIWYMField('description',
        schemata='default',
        widget=LeVisualWidget(
            rows=5,
            cols=40,
            label='Description',
            label_msgid='label_description',
            i18n_domain='lemill'
            )
    ),
    LinesField('language_skills',
        default = [],
        index = 'KeywordIndex:schema',
        vocabulary = 'getLanguagelist',
        widget = PicklistWidget(            
             label = 'Languages',
             label_msgid = 'label_group_language_skills',
             description = "Choose languages that the group is willing to use. This affects only when people try to find groups based on a language.",
             description_msgid = 'help_group_language_skills',
             i18n_domain = "lemill"
             )
        ),        
    LinesField('recent_posts',
        default= [],
        widget = LinesWidget(
            visible = {'view':'invisible', 'edit':'invisible'},
            )
        ),
    LinesField('groupMembers',
        default=[],
        index = 'KeywordIndex:schema',
        widget = LinesWidget(
            visible = {'view':'invisible', 'edit':'invisible'},
            ),
        ),
 ))

schema = BaseFolderSchema + tags + coverImage + deletionReason + score + subject_area_schema + latest_edit_schema + state + groupblog_schema

schema = schema.copy()
schema['allowDiscussion'].widget.visible = {'edit':'invisible', 'view':'invisible'}
schema['subject'].widget.visible = {'edit':'invisible', 'view':'invisible'}
schema['contributors'].widget.visible = {'edit':'invisible', 'view':'invisible'}
schema['creators'].widget.visible = {'edit':'invisible', 'view':'invisible'}
schema['language'].widget.visible = {'edit':'invisible', 'view':'invisible'}
schema['rights'].widget.visible = {'edit':'invisible', 'view':'invisible'}
schema['tags'].schemata='default'
schema['tags'].widget.description = "Enter descriptive tags for this group, separated by commas."
schema['tags'].widget.description_msgid = 'description_group_tags'
schema['subject_area'].schemata='default'
schema.moveField('subject_area', after='language_skills')
schema['subject_area'].searchable = True
schema['subject_area'].widget.description = "Choose curriculum subject areas that are appropriate for this group."
schema['subject_area'].widget.description_msgid = 'description_group_subject_area'


class GroupBlog(CommonMixIn, LeMillFolder, BaseFolder):
    """Group blog"""

    meta_type = "GroupBlog"
    archetype_name = "GroupBlog"  
    default_location = 'community/groups'

    global_allow = 1

    portlet = 'here/portlet_groupblog_actions/macros/portlet'
    allowed_content_types = ('BlogPost')
    default_view = ('groupblog_view')
    filter_content_types = True
    security = ClassSecurityInfo()
    schema = schema

    actions = ({ 'id':'view',
                 'name': 'View',
                 'action': 'string:${object_url}/groupblog_view',
                 'permissions': (VIEW,)
               },
               { 'id':'edit',
                 'name': 'Edit',
                 'action': 'string:${object_url}/base_edit',
                 'permissions': (MODIFY_CONTENT,)
               },
               )
    aliases = {
        '(Default)' : '',
        'view'      : 'groupblog_view',
        'edit'      : 'base_edit',
        'edit_categories' : 'base_metadata',
        'edit_links' : 'base_metadata',
    }

    def manage_afterAdd(self, item, container):
        BaseFolder.manage_afterAdd(self, item, container)
        # We need this to get at_post_edit script running, as we are creating groups automatically
        # This way processForm does not run
        self.at_post_create_script()

    def helper_updateCatalogUID(self):
        self._catalogUID(self)

    def at_post_create_script(self):
        lutool = getToolByName(self, 'lemill_usertool')
        memberfolder=lutool.getMemberFolder()
        if memberfolder:
            memberfolder.recalculateScore()
        # Enable topic syndication by default
        syn_tool = getToolByName(self, 'portal_syndication', None)
        if syn_tool is not None:
            if syn_tool.isSiteSyndicationAllowed():
                try:
                    syn_tool.enableSyndication(self)
                except: # might get 'Syndication Information Exists'
                    pass
        

    def at_post_edit_script(self):
        old_id=self.id
        self._renameAfterCreation()
        # If id has changed, update posts to have correct parent's id 
        if old_id!=self.id: 
            for post in self.objectValues('BlogPost'):
                post.setParentBlog(self.id)
                post.reindexObject(['getParentBlog'])
        self.recalculateScore()
        self.reindexObject()
        # See if we need to reindex Title in the uid_catalog
        uid = self.UID()
        utool = getToolByName(self, 'uid_catalog')
        objlist = utool({'UID':uid})
        if objlist:
            if self.Title() != objlist[0].Title:
                self.helper_updateCatalogUID()

    def getMetaDescription(self):
        """ Use group description for header metadata   """
        return self.getDescription() 


    def getCreatorsString(self, as_links=True):
        """ Get creators for this object, update schema if necessary """
        field=self.getField('creators')
        if not hasattr(field.widget, 'displayString'):
            print 'has to update'
            self.updateSchema()
            field=self.getField('creators')
            if not hasattr(field.widget, 'displayString'):
                return '' 
        return field.widget.displayString(self, self.getAuthors(), as_links=as_links)

            
    def getGroupMaterials(self, n=False, as_dict=False):
        """ Get resources edited by this group """
        pc=getToolByName(self, 'portal_catalog')        
        results=pc({'getRawGroupEditing':self.UID(), 'getState':('public','draft')})
        if as_dict:
            # Make a dictionary with following keys: 'Content','Activities','Tools'
            dict={'Content':[],'Activities':[],'Tools':[]}
            for res in results:
                if res.meta_type in MATERIAL_TYPES:
                    dict['Content'].append(res)
                elif res.meta_type=='Activity':
                    dict['Activities'].append(res)
                elif res.meta_type=='Tool':
                    dict['Tools'].append(res)
            if n:
                for key in dict.keys():
                    dict[key]=len(dict[key])
            return dict                   

        if n:
            return len(results)
        else:
            return results

    def getGroupMembersNamesAndUrls(self):
        """ Returns a list of tuples, where first element is nice name and second element is url """
        memberids= self.getGroupMembers()
        lutool=getToolByName(self, 'lemill_usertool')
        if memberids:        
            return [(md.getNicename, md.getURL()) for md in lutool.getMemberFolderMetadata(memberid=memberids)]
        else:
            return []

    def getLatestEditDate(self):
        """Returns creation date, we don't want to notify about every edit"""
        return DateTime(self.CreationDate())

    def getLastEditor(self):
        """ Returns creator, we don't have any history for this one """
        return self.Creator()

    def getSamples(self):
        """ get n number of samples """
        pc=getToolByName(self, 'portal_catalog')        
        results=pc({'getRawGroupEditing':self.UID(), 'getState':'public', 'portal_type':tuple(self.getFeaturedTypes()), 'getHasCoverImage':True})
        n = min(4, len(results))
        return random.sample(results,n)

    def getCoverImageURL(self, drafts=False):
        """Returns the URL for the cover image."""
        if self.getField('hasCoverImage').get(self)==True:
            return self.absolute_url()+'/coverImage'
        portal_url=getToolByName(self, 'portal_url')
        return portal_url()+'/images/default_group.png' 
        
    def isPost(self):
        return False        
        
    def getNicename(self):
        """ To make GroupBlogs compatible with MemberFolders """
        return self.Title()

    def getLanguagelist(self):
        return DisplayList(LANGUAGES) 

    def canIEdit(self, member=None):
        """ Override resources canIEdit: in groups only group members can edit (and managers, of course) """
        if not member:
            lutool=getToolByName(self, 'lemill_usertool')        
            member=lutool.getAuthenticatedMember()     
        return self.isMember(member.getId()) or self.canIManage()

    def isMember(self, memberid):
        return memberid in self.getGroupMembers()

    def canIModerate(self):
        lutool=getToolByName(self, 'lemill_usertool')        
        roles = lutool.getAuthenticatedMember().getRolesInContext(self)
        return 'Manager' in roles or 'Reviewer' in roles
        
    def getPosts(self, batch=True, b_size=30, b_start=0, objects=True, limit=0, remove_zeros=False):
        """ Return get posts as *metadata* objects, sort them by date and batch them """
        pc= getToolByName(self,'portal_catalog')
        blogposts=pc({'portal_type':'BlogPost', 'getState':'public', 'path':'/'.join(self.getPhysicalPath()[1:])})
        resources=pc({'getRawGroupEditing':self.UID(), 'getState':('public','draft')})
        if remove_zeros:        
            resources = filter(lambda x: x.postCount, resources)
            blogposts = list(blogposts) # this is required as the filter operation changes lazy catalog object to list
            # and blogposts need to be list too so that they can be concatenated
        results=[(int(DateTime(r.getLastCommentDate).timeTime()), r.aq_base, r) for r in blogposts+resources if r.getLastCommentDate]
        results.sort()
        results.reverse()        
        results=[c for a,b,c in results]
        if limit:
            results = results[:limit]
        if batch:
            results = Batch(results, b_size, int(b_start), orphan=0)
        if objects:
            results = [r.getObject() for r in results]
        return results


    def getBlog(self):
        return self
 
 
    def linkToLatestComment(self, post_md):
        """ Takes a catalog metadata object and returns an url that links either
         to blogpost's last anchor or resource's discussion page """ 
        if post_md.portal_type=='BlogPost':
            url=post_md.getURL()
        else:
            url='%s/discussion' % post_md.getURL()
        if not post_md.postCount:
            return url
        anchor=int(DateTime(post_md.getLastCommentDate).timeTime())
        return '%s#%s' % (url,anchor)

        
    security.declareProtected(MODIFY_CONTENT,'addRecent_post')
    def addRecent_post(self,postid):
        """ Recent posts are lists of id's, because then picking the post objects when inside group is easy and quick """
        # sometimes this method gets called before new blogposts get their proper id:s, so escape then:
        if postid.startswith('blogpost.'):
            return None
        postlist= list(self.getField('recent_posts').get(self))
        if postid in postlist:
            postlist.remove(postid)
        postlist=[postid]+postlist
        self.setRecent_posts(postlist[:10])            

    security.declareProtected(MODIFY_CONTENT,'removeRecent_post')
    def removeRecent_post(self,postid):
        postlist= [post_id for post_id in self.getRecent_posts() if not post_id==postid]
        self.setRecent_posts(postlist)            

    security.declareProtected(MODIFY_CONTENT,'replaceRecent_post')
    def replaceRecent_post(self, old, new):
        postlist= list(self.getRecent_posts())
        postlist[postlist.index(old)]=new
        self.setRecent_posts(postlist)            

    def addMember(self, memberid):
        users=list(self.getGroupMembers())
        if memberid in users:
            return False
        self.setGroupMembers(users+[memberid])
        self.reindexObject()
        return True
            
    def removeMember(self, memberid):
        users=list(self.getGroupMembers())
        if memberid not in users:
            return False
        users.remove(memberid)
        self.setGroupMembers(users)
        self.reindexObject()
        if len(users)==0:
            self.community.groups._delObject(self.id)
        return True
        
            
    def join_group(self, redirect=True):
        """ The logged in user joins the current group """
        lutool = getToolByName(self, 'lemill_usertool')
        ltool= getToolByName(self, 'lemill_tool')
        if lutool.isAnonymousUser():
            ltool.addPortalMessage(_("You have to be logged in to join a group."))
            return self.REQUEST.RESPONSE.redirect(self.absolute_url())            
        userid = lutool.getAuthenticatedId()                
        if self.addMember(userid):
            ltool.addPortalMessage(_("You have joined the group '${title}'."), mapping={'title':self.title_or_id()})
            self.notifyGroupJoin()
        else:
            ltool.addPortalMessage(_("You are already member in this group."))
        if redirect:
            return self.REQUEST.RESPONSE.redirect(self.absolute_url())
    
    def leave_group(self):
        """ The logged in user leaves the current group """
        REQUEST=self.REQUEST
        lutool = getToolByName(self, 'lemill_usertool')
        ltool= getToolByName(self, 'lemill_tool')
        userid = lutool.getAuthenticatedId()        
        if self.removeMember(userid):
            ltool.addPortalMessage(_("You have left the group '${title}'."), mapping={'title':self.title_or_id()})
        else:
            ltool.addPortalMessage(_("You are not member in this group."))
        return REQUEST.RESPONSE.redirect(self.community.absolute_url())

 
        

    # These have to be duplicated since its difficult to base these folderish objects on non-folderish Resources 

    security.declareProtected(MODIFY_CONTENT,'setCoverImage')
    def setCoverImage(self, value, **kwargs):
        """ Normal mutator, but flags object to have a coverImage (hasCoverImage = True) """
        cover=self.getField('coverImage')
        cover.set(self,value,**kwargs)
        has_cover=self.getField('hasCoverImage')
        has_cover.set(self,True)

    security.declareProtected(MODIFY_CONTENT,'delCoverImage')
    def delCoverImage(self):
        """ Reverse of setCoverImage """
        cover=self.getField('coverImage')
        cover.set(self,None)
        has_cover=self.getField('hasCoverImage')
        has_cover.set(self,False)


    def recalculateScore(self):
        """ Calculates the score for Group Blog according to specifications """
        lt = getToolByName(self, 'lemill_tool')
        score = float(0)
        members_score = len(self.getGroupMembers())
        materials = self.getGroupMaterials()
        posts = self.getPosts(batch=False)

        score = score + members_score

        for m in materials:
            months_old = lt.getTimeDifference(m.getLatestEdit)
            months_old = months_old['months']
            score = score + 1 / float(months_old + 1)

        for p in posts:
            months_old = lt.getTimeDifference(p.getLatestEditDate())
            months_old = months_old['months']
            score = score + 1 / float(months_old + 1)

        score = int(round(score))

        # This one is not really needed, because Group must have at least one member
        if score<1:
            score = 1
        # Now to set the value for field score
        self.setScore(score)

    def portfolioFilter(self):
        """ Used for filtering group portfolio to show only resources where this group is editing """
        return ('getRawGroupEditing',self.UID())


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

        v={'canChangeCoverImage':False,
            'mainView':True,
            'manageGroup':False,
            'joinGroup':'',
            'leaveGroup':False,
            'groupMembers':[],
            'groupResources':{}
        }
        
        ################ Mandatory flags    

        canEdit= self.canIEdit(member)
        view_id=REQUEST['URL'].split('/')[-1]
        url=self.absolute_url()
        isDeleted = self.isDeleted()

        v['mainView'] = mainView = view_id!='lemill_portfolio_view'

        v['canChangeCoverImage'] = mainView and canEdit and not isDeleted
        v['manageGroup'] = canEdit
        if isAnon:
            v['joinGroup'] = 'login_form'
        elif member.getId() not in self.getGroupMembers():
            v['joinGroup'] = 'join_group'             
        v['leaveGroup'] = not v['joinGroup']
        v['groupMembers'] = self.getGroupMembersNamesAndUrls()
        v['groupResources'] = self.getGroupMaterials(n=True, as_dict=True)
        return v

    security.declarePrivate('notifyGroupJoin')
    def notifyGroupJoin(self):
        lutool = getToolByName(self, 'lemill_usertool')
        auth_mf = lutool.getMemberFolder()
        if self.Creator() != lutool.getAuthenticatedId():
            mf = lutool.getMemberFolder(self.Creator())
            if mf and mf.canNotify('group_joined'):
                ltool=getToolByName(self, 'lemill_tool')
                language=lutool.getCommunicationLanguage(mf)
                dict={'name':to_unicode(auth_mf.getNicename()),
                    'title':to_unicode(self.Title()),
                    'url':to_unicode(self.absolute_url())}                
                msg = self.translate("'%(name)s has joined your group '%(title)s': %(url)s",domain="lemill",target_language=language) % dict
                ltool.mailNotification(msg, recipient=mf.getEmail(), language=language)

    security.declarePrivate('notifyNewThread')
    def notifyNewThread(self):
        lutool = getToolByName(self, 'lemill_usertool')
        auth_mf = lutool.getMemberFolder()
        if self.Creator() != lutool.getAuthenticatedId():
            mf = lutool.getMemberFolder(self.Creator())
            if mf and mf.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=mf.getEmail(), language=language) 

    ################# RSS ######################################

    def getRSSResults(self, max=30):
        """ Returns latest forum topics and comments 
        metadata returned:
        'getURL', 'getLatestEdit', 'Title', 'listCreators','Rights'
        """
        results=self.getPosts(batch=False, objects=True, limit=10)
        sortable_results=[]
        for result in results:
            r_dict={'getURL':result.absolute_url(), 'getLatestEdit':result.created(), 'Title':result.Title(), 'listCreators':[result.Creator()], 'Rights':'CC-SA 2.5'} 
            sortable_results.append((result.created(), r_dict))
            url_base=result.absolute_url() 
            title='re:%s' % result.Title()
            if result and hasattr(result, 'getDiscussion'):                
                for reply in result.getDiscussion().values():
                    r_dict={'getURL':'#'.join((url_base, reply.id)), 'getLatestEdit':reply.created, 'Title':title, 'listCreators':[reply.Creator()],'Rights':'CC-SA 2.5'}
                    sortable_results.append((reply.created, r_dict))
        sortable_results.sort(reverse=True)
        rez= [x[1] for x in sortable_results[:max]]
        return rez    

        

registerType(GroupBlog, PROJECTNAME)