root/trunk/PresentationMaterial.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-1


from AccessControl import ClassSecurityInfo, getSecurityManager
from Products.Archetypes.public import *
from Products.CMFCore.utils import getToolByName
from config import PROJECTNAME,SLIDESHARE_API_KEY,SLIDESHARE_SECRET_KEY
from FieldsWidgets import AudioField, ChapterField, AudioWidget, LeTextAreaWidget, SlideWidget, EmbedWidget
from Schemata import material_schema, community_editing_schema, draft_schema
from Material import Material
from types import ListType
from permissions import MODIFY_CONTENT
from persistent.mapping import PersistentMapping 
from Products.LeMill import LeMillMessageFactory as _
from Products.CMFPlone.PloneBatch import Batch

from xml.dom.minidom import parse
import urllib, urllib2
import time, sha, calendar
import DateTime


presentation_schema= Schema((
    AudioField('audio', # deprecates, won't be used by SlideShare presentations
        accessor='getAudioFile',
        mutator='setAudioFile',
        widget=AudioWidget(label="Audio recording",
            label_msgid="label_audio_recording",
            description="An audio recording of the presentation",
            description_msgid="help_presentation_audio_recording",
            i18n_domain="lemill",
            visible ={'edit':'invisible', 'view':'visible'}
            ),
        ),
   StringField('description',
        accessor="getDescription",
        mutator = "setDescription",
        index='ZCTextIndex',
        schemata='default',
        searchable = True,
        widget=LeTextAreaWidget(label = "About the presentation",
            label_msgid = "label_presentation_about",
            description = "General information about the presentation such as the data, event and location.",
            description_msgid = "help_presentation_about",
            rows = 4,
            i18n_domain = "lemill",
            visible ={'edit':'visible', 'view':'visible'}
            ),
    ),
    ChapterField('bodyText', # deprecates, won't be used by SlideShare presentations
        accessor = 'getBodyText',
        edit_accessor = 'getRawBodyText',
        mutator = "setBodyText",
        copied_in_translation=True,
        index='ZCTextIndex',
        index_method = 'getOnlyText',
        searchable = True,
        allowable_content_types = ['text/html',],
        allow_file_upload = False,
        default_output_type = 'text/x-html-captioned',
        default_content_type = 'text/html',
        default=[],
        deleteEmptyChapters = False,
        widget=SlideWidget(label = "Slides and captions",
            label_msgid = "label_slides_and_captions",
            i18n_domain = "lemill",
            ),
    ),
    StringField('ss_id', 
        searchable = False,
        widget = StringWidget(
            visible = {'view':'invisible', 'edit':'invisible'},
            ),
    ),
    StringField('permalink', 
        searchable = False,
        widget = StringWidget(
            visible = {'view':'visible', 'edit':'invisible'},
            ),
    ),
    StringField('thumbnail', 
        searchable = False,
        widget = StringWidget(
            visible = {'view':'invisible', 'edit':'invisible'},
            ),
    ),
    StringField('embedCode', 
        searchable = False,
        widget = EmbedWidget(
            visible = {'view':'visible', 'edit':'visible'},
            ),
    ),

))

schema = material_schema + community_editing_schema + presentation_schema 

schema = schema.copy()
schema.moveField('rights', pos='bottom')
schema['title'].required = True
schema['tags'].schemata='default'
schema.moveField('embedCode', before='description')

SIZES = (('small', (120, 120)), ('edit', (500, 500)), ('large', (700, 525)))

class PresentationMaterial(Material):
    """ Presentation """

    schema = schema

    meta_type = "PresentationMaterial"
    archetype_name = "PresentationMaterial"
    default_location = 'content/presentations'

    security = ClassSecurityInfo()
    security.declareObjectPublic()

    aliases = {
        '(Default)' : 'slideshow_view',
        'view'      : 'base_view',
        'edit'      : 'base_edit'
    }

    def manage_afterAdd(self, item, container):
        if not hasattr(self, 'temp_data'):
            print 'no temp_data, creating empty dict'            
            self.temp_data = {} # this has to be persistent just to get this to work. 
        Material.manage_afterAdd(self, item, container)

    def hasComplexWorkflow(self):
        """ Can have drafts or versions """
        return False

    def hasEditableCoverImage(self):
        """ Cover Image is not created automatically """
        return False

    def getOnlyText(self):
        field=self.getField('bodyText')
        values = field.get(self)
        if not values:
            return ''
        if type(values[0])==tuple:
            dump= '\n'.join([x[0] for x in values if x[1]=='caption'])
        else:
            dump= '\n'.join([x['text'] for x in values if x['text']])
        if dump.isspace():
            return ''
        else:
            return dump

    def getOnlyRawText(self):
        field=self.getField('bodyText')
        values = field.getRaw(self)
        if values:
            return '\n'.join([x[0] for x in values if x[1]=='caption'])
        return ''

    def getSlidesAsTuples(self):
        """ Helper method for slideshows, returns (slide_src, thumb_src , caption) -tuples """
        portal_url = getToolByName(self, 'portal_url')
        thelist=[]
        caption=slide_src=thumb_src=''
        for (chapter,chapter_type) in self.getRawBodyText():
            if chapter_type=='caption':
                thelist.append((slide_src, thumb_src, chapter))
            elif chapter_type=='image_piece' and self.isUid(chapter):
                piece=self.getObjectByUID(chapter)
                if piece and hasattr(piece, 'image_large') and hasattr(piece, 'image_small'):
                    slide_src='%s/image_large' % piece.absolute_url()
                    thumb_src='%s/image_small' % piece.absolute_url()
                else:
                    slide_src=''
                    thumb_src=''                        
            else:
                slide_src=''
                thumb_src=''
        return thelist 

    def deleteResource(self, reason=''):
        pieces_to_delete = []
        for chapter in self.getRawBodyText():
            if chapter['type']=='image_piece':
                piece=self.getObjectByUID(chapter['uid'])
                if piece and len(piece.getResourcesUsingPiece())==1:
                    pieces_to_delete.append(piece)
        Material.deleteResource(self)
        for piece in pieces_to_delete:
            piece.deleteResource()

    # New, SlideShare related methods

    security.declareProtected(MODIFY_CONTENT, 'fetchAllPresentations')
    def fetchAllPresentations(self):
        """ dictionary of SlideSharePresentations for current users """
        lutool=getToolByName(self, 'lemill_usertool')
        ss_user=lutool.getMemberFolder().getSlideshare_username()
        if not ss_user:
            return {}
        data=self.getSlideshowsByUser(username_for=ss_user)
        self.temp_data=self.parseSlideshareXML(data)

    def getBatchOfPresentations(self,b_start=0, b_size=10):
        """ Returns importable presentations in sorted and batched sets """        
        if not getattr(self, 'temp_data', {}):
            self.fetchAllPresentations()
        list_of_p=[(x['date'], x) for x in self.temp_data.values()]
        list_of_p.sort(reverse=True)
        batchbase=[value for (date, value) in list_of_p]
        batch=Batch(batchbase, b_size, int(b_start), orphan=0)
        return batch

    def uploadedPresentations(self):
        """ Returns a list of slideshare ids that the user has already imported """
        return [] 

    security.declareProtected(MODIFY_CONTENT, 'injectPresentationFromSlideShare')
    def injectPresentationFromSlideShare(self):
        """ modifies the current presentation with data from slideshare """
        REQUEST=self.REQUEST
        key=REQUEST.form.get('slideshare_id','')
        cancel=REQUEST.form.get('form.button.cancel','')
        if cancel:
            if hasattr(self, 'temp_data'):
                del self.temp_data
            portal_url=getToolByName(self,'portal_url')
            lt=getToolByName(self,'lemill_tool')
            lt.addPortalMessage('Resource cancelled.')
            self.aq_parent.manage_delObjects([self.id])
            return REQUEST.RESPONSE.redirect(portal_url()+'/content')
        if not key:
            return REQUEST.RESPONSE.redirect(self.absolute_url()+'/import_presentation')
        if not hasattr(self, 'temp_data'):
            lutool=getToolByName(self, 'lemill_usertool')
            ss_user=lutool.getMemberFolder().getSlideshare_username()
            self.temp_data=self.parseSlideshareXML(self.getSlideshowsByUser(ss_user))
        data=self.temp_data.get(key, None)        
        if not data:
            raise 'SlideShare id %s not found' % str(key)
            return REQUEST.RESPONSE.redirect(self.absolute_url()+'/import_presentation')
        self.edit(**data)
        # We need to get this particular slideshow by id to get new style (working) slideshow. 
        this_slideshow=self.parseSlideshareXML(self.getSlideshowById(slideshow_id=key))
        if this_slideshow:
            self.setEmbedCode(this_slideshow[key]['embedCode'])
        thumbnail=self.getThumbnail()
        if thumbnail:
            coverImageFile=urllib2.urlopen(thumbnail).read()
            if coverImageFile:
                self.setCoverImage(coverImageFile)
        self.publish()
        self.at_post_edit_script()
        del self.temp_data        
        return REQUEST.RESPONSE.redirect(self.absolute_url()+'/base_edit')        

    security.declarePrivate('getSlideshowsByUser')
    def getSlideshowsByUser(self, username_for=None):
        """ Fetch XML-data from SlideShare """
        print '*** Fetching from SlideShare ***'
        ts = int(time.time())
        params = {'api_key' : SLIDESHARE_API_KEY,'ts' : ts, 'hash' : sha.new(SLIDESHARE_SECRET_KEY + str(ts)).hexdigest(), 'username_for':username_for}
        params = urllib.urlencode(params)
        data=urllib2.urlopen('http://www.slideshare.net/api/1/get_slideshow_by_user', params)
        return data    

    security.declarePrivate('getSlideshowById')
    def getSlideshowById(self, slideshow_id=None, slideshow_url=None):
        """ Fetch XML-data from SlideShare """
        ts = int(time.time())
        params = {'api_key' : SLIDESHARE_API_KEY,'ts' : ts, 'hash' : sha.new(SLIDESHARE_SECRET_KEY + str(ts)).hexdigest(), 'slideshow_id':slideshow_id, 'slideshow_url':slideshow_url or 'blank'}
        params = urllib.urlencode(params)
        data=urllib2.urlopen('http://www.slideshare.net/api/2/get_slideshow', params)
        return data
    
    def parseSlideshareXML(self, xml_data):    
        """ builds a dict of useful LeMill data from SlideShare's XML """
        def getTag(dom, tag):
            content=dom.getElementsByTagName(tag)
            if content:
                content=content[0].childNodes
                for node in content:
                    if node.nodeType==node.TEXT_NODE:
                        return node.data         
            return ''
        dom=parse(xml_data)
        slideshows=dom.getElementsByTagName("Slideshow")
        dict={}
        for ss in slideshows:
            obj={}
            id=getTag(ss, 'ID')
            obj['ss_id']=id
            obj['title']=getTag(ss, 'Title')
            obj['description']=getTag(ss, 'Description')
            date=getTag(ss, 'Created')
            if date:
                try:
                    date=time.strptime(date, '%a %b %d %H:%M:%S %Z %Y')
                    date=calendar.timegm(date)
                    date=DateTime.DateTime(date)
                except ValueError:
                    date=DateTime.DateTime()
            obj['date']=date
            tags=getTag(ss, 'Tags')
            if tags:
                tags=', '.join(tags.split(' '))
            obj['tags']=tags
            obj['permalink']=getTag(ss, 'Permalink')
            obj['thumbnail']=getTag(ss, 'Thumbnail')
            obj['embedCode']=getTag(ss,'Embed') or getTag(ss, 'EmbedCode')
            dict[id]=obj
        dom.unlink()
        return dict


registerType(PresentationMaterial, PROJECTNAME)