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

# -*- coding: iso-8859-1 -*-

from Acquisition import aq_get
from AccessControl import Permissions, getSecurityManager
from zExceptions import BadRequest
from OFS.PropertyManager import PropertyManager
from zLOG import INFO, ERROR
from Globals import package_home
from Products.ZCatalog.Catalog import CatalogError

from Products.CMFCore.utils import getToolByName
from Products.CMFCore.FSFile import FSFile

from Products.CMFCore.DirectoryView import registerDirectory, addDirectoryViews, registerFileExtension

from Products.CMFCore.ActionInformation import ActionInformation
from Products.CMFPlone.migrations.migration_util import safeEditProperty
from Products.CMFPlone.PloneFolder import addPloneFolder
from Products.CMFPlone.setup.SetupBase import SetupWidget
from Products.SiteErrorLog.SiteErrorLog import manage_addErrorLog
from Products.Archetypes.public import listTypes, registerType
from Products.Archetypes.Extensions.utils \
     import installTypes, install_subskin
from Products.PythonScripts.PythonScript import PythonScript
from Products.LeMill.LatexTool import workingDir
from Acquisition import aq_inner, aq_parent


from DateTime import DateTime
import string, types
from cStringIO import StringIO
from os import path

from config import *


# All methods starting with "setup" will be used in the customization policy
# The methods will be sorted by ascii value, so if something  needs to happen before
# something else, make it so (see method setup001Dependencies).

# Note that all methods need to be repeatable - they should not fail
# if they are run again when all that they do has already been done.
# Also, the methods should be able to upgrade, meaning that older customizations
# should be changed to match the newest specifications.

def setup001Dependencies(self, portal):
    """Install all necessary products into the plone instance."""
    qi=getToolByName(portal, 'portal_quickinstaller')
    # We need ourselves installed into the plone instance,
    # since we provide portal tools and content
    qi.installProduct('LeMill')
    # LanguageTool is also necessary
    qi.installProduct('PloneLanguageTool')
    if FS_STORAGE:
        qi.installProduct('FileSystemStorage')

def setupSkin(self,portal):
    """Create new custom skin."""
    skinsTool = getToolByName(portal,"portal_skins")

    # Register our own skin folder as a viewable folder
    try:
        addDirectoryViews(skinsTool,SKINS_DIR,GLOBALS)
    except:
        # If the directory is already registered, we just continue
        pass

    # Create our new skin, making it a copy of BASE_SKIN and adding
    # our skin layer just after "custom".
    if SKIN_NAME not in skinsTool.getSkinSelections():
        path = skinsTool.getSkinPath(BASE_SKIN)
        path = map(string.strip,string.split(path,','))
        if SKIN_NAME not in path:
            try:
                path.insert(path.index('custom')+1,SKIN_NAME)
            except ValueError:
                path.append(SKIN_NAME)
        path=string.join(path,',')
        skinsTool.addSkinSelection(SKIN_NAME,path)

    # Select our first skin as default
    skinsTool.default_skin=SKIN_NAME

    # Allow fonts into skins.
    registerFileExtension('ttf', FSFile)


def addObject(portal,id,type,title,desc=None):
    """Convenience method for creating new content items."""
    try:
        portal.invokeFactory(id=id,type_name=type)
    except BadRequest:
        # If the id already existed, we'll just quietly be happy about it.
        pass
    finalizeObject(portal,id,title,desc)

def finalizeObject(portal,id,title,desc=None):
    """Set content object properties in place."""
    ob=getattr(portal,id)
    
    # Set basic properties of object
    ob.setTitle(to_unicode(title))
    if desc:
        ob.setDescription(to_unicode(desc))
        
    # Publish content
    ob.setState="public"

def setupFrontPage(self,portal):
    """Setup the front page."""
    # Make sure that old PythonScript for redirecting isn't there anymore
    # the content section.
    try:
        portal._delObject('front-page')
    except AttributeError:
        pass


def setupLatexSupport(self, portal):
    """Setup localfs for latex-images."""
    if not LATEX_IMAGES_STORAGE_PATH:
        return
    
    if not hasattr(portal, LATEX_IMAGES_STORAGE_PATH):
        ob = None 
        try: 
            from Products.LocalFS.LocalFS import LocalFS 
            ob = LocalFS(LATEX_IMAGES_STORAGE_PATH, '', workingDir, None, None) 
            portal._setObject(LATEX_IMAGES_STORAGE_PATH, ob, set_owner=1)

        except ImportError: # no localfs
            pass

def setupFontsFolder(self, portal):
    """ Setup fonts for pdf-creation """
    
    if not hasattr(portal, 'fonts'):
        ob = None 
        fontpath=path.join(package_home(globals()), 'fonts/')
        ob = None 
        try: 
            from Products.LocalFS.LocalFS import LocalFS 
            ob = LocalFS('fonts', '', fontpath, None, None) 
            portal._setObject('fonts', ob, set_owner=1)

        except ImportError: # no localfs
            pass



                  
def setupFolders(self,portal):
    """Setup the basic structure of the site."""

    def createSection(base, section):
        section_id=section.lower()
        section_type=SECTION_FOLDER_TYPES[section]
        if not hasattr(base, section_id):
            addObject(base,section_id,section_type,section)
        else:
            folder = getattr(base, section_id)
            if folder.portal_type != section_type:
                base._delObject(section_id)
                addObject(base,section_id,section_type,section)
        folder = getattr(base,section_id)
        folder.manage_permission(ADD_CONTENT_PERMISSION, ('Member',), acquire=1) 
        folder.manage_permission(LIST_FOLDER_CONTENTS, ('Member',), acquire=1)
        folder.manage_permission(ADD_TOPICS, ('Member',), acquire=1)
        return folder


    # Loop through all main sections
    for (section, subsections) in SECTIONS.items():
        section=createSection(portal, section)
        # Loop through their subsections
        for subsection in subsections:
            subsection=createSection(section, subsection)                            

    # Setup additional Trash folder for deleted resources
    # It might be a good idea to make any actions including View only usable by users with Manager permission
    trash_folder = 'Trash'
    trash_type = 'LargeTrashFolder'

    if not hasattr(portal, trash_folder.lower()):
        addObject(portal,trash_folder.lower(),trash_type,trash_folder)
    folder = getattr(portal,trash_folder.lower())
    folder.manage_permission(ADD_CONTENT_PERMISSION, ('Member',), acquire=1)
    for section, toplist in SECTION_TOPLISTS.items():
        section=getattr(portal, section)
        for top3 in toplist:
            if not hasattr(section, top3):
                section.manage_addProperty(top3, [], 'lines')
        
        


def setupReadOnlyMode(self, portal):
    stp = getToolByName(portal,'portal_properties').site_properties
    if not hasattr(stp, 'readonly_mode'):
        stp.manage_addProperty('readonly_mode',False,'boolean')


def setupSiteSyndication(self, portal):
    # Enable syndication
    syn_tool = getToolByName(portal, 'portal_syndication')
    syn_tool.editProperties(isAllowed=True)
    #safeEditProperty(syn_tool,'isAllowed',True)
    
def setupCatalog(self,portal):
    # put 'language' and 'subject' in catalog index and retrieved metadata
    # from http://plone.org/documentation/how-to/adding-new-fields-to-smart-folders-search
    # these are metadata fields from basic plone objects.

    class args:
            def __init__(self, **kw):
                self.__dict__.update(kw)
            def keys(self):
                return self.__dict__.keys()


    catalog_tool = getToolByName(portal, 'portal_catalog')
    # (jukka, 10.1.2008) I commented away deleting indexes before adding them, as this forces us to always update catalog after running these
    # We can restore them if we do changes that really change probably existing indexes

    #try:
    #    catalog_tool._removeIndex("Language")
    #except:
    #    pass
    #try:
    #    catalog_tool.delColumn("Language")
    #except:
    #    pass

    extra = args(doc_attr='Language',
                 lexicon_id='plone_lexicon',
                 index_type='Okapi BM25 Rank')
    try:
        catalog_tool.manage_addIndex("Language", "FieldIndex", extra)
    except CatalogError:
        pass # index already exists
    try:
        catalog_tool.manage_addColumn("Language")
    except CatalogError:
        pass # metadata already exists

    #try:
    #    catalog_tool.delColumn("sortable_title")
    #except:
    #    pass
    try:
        catalog_tool.manage_addIndex("sortable_title", "FieldIndex")    
    except CatalogError:
        pass # index already exists
    try:
        catalog_tool.manage_addColumn("sortable_title")    
    except CatalogError:
        pass # metadata already exists
    #try:
    #    catalog_tool.delColumn("UID")
    #except:
    #    pass

    extra = args(doc_attr='UID',
                 lexicon_id='plone_lexicon',
                 index_type='Okapi BM25 Rank')
    try:
        catalog_tool.manage_addIndex("UID", "FieldIndex", extra)    
    except CatalogError:
        pass # index already exists
    try:
        catalog_tool.manage_addColumn("UID")
    except CatalogError:
        pass # metadata already exists

    # The meta_type was gone from the catalog Metadata, we need it back
    try:
        catalog_tool.manage_addColumn("meta_type")
    except CatalogError:
        pass # metadata already exists


    try:
        catalog_tool.manage_addColumn("postCount")
    except CatalogError:
        pass # metadata already exists
    try:
        catalog_tool.manage_addColumn("getLastCommentDate")
    except CatalogError:
        pass # metadata already exists
    
        
    # BAD INDEXES AND METADATA:
#    bads=['Description','EffectiveDate','ExpirationDate','Subject','effective','end','exclude_from_nav','expires',    
#'getActivity_score','getAge_group','getCategory','getDescription','getEndUserRole','getFullname','getIcon',
#'getLearningContext','getLearningResourceType','getLocation','getNickname','getObjSize','getRemoteUrl',
#'getShortDescription','getUsed_content','in_reply_to','is_default_page','is_folderish','location','start','getRawRelatedActivities', 'effectiveRange', 'getEventType']
#
#    for b in bads:
#        try:
#            catalog_tool.delColumn(b)
#            print 'removed metadata %s' % b
#        except:
#            pass
#        try:
#            catalog_tool._removeIndex(b)
#            print 'removed index %s' % b
#        except:
#            pass


def setupTopics(self, portal):
    """ From v 3.0-> we don't use topics anymore. This method makes sure they are removed. :/ """
    removed_topics = {
        'content': ['tags','published','browse_resources','drafts','language','subject_area','target_group','browse_references','browse_pieces','recent'],
        'methods': ['language','tags','published','browse_methods'],
        'tools': ['language','tags','published','browse_tools'],
        'community':['portfolio','browse_people','language','country','skills','interests','subject_area','browse_groups','tags','g_language','group_subject_area']
    } 
    for section,topic_ids in removed_topics.items():
        section=getattr(portal, section)
        del_ids=[]
        for topic_id in topic_ids:
            topic= getattr(section, topic_id, None)
            if topic and getattr(topic, 'meta_type','') == 'ATTopic':
                del_ids.append(topic_id)
        if del_ids:
            print 'deleting obsolete topics:', del_ids
            section.manage_delObjects(del_ids)
    # Also remove every Topic from catalog, there are some legacy stuff that has survived.
    pc=portal.portal_catalog
    for topic_md in list(pc(portal_type='Topic')): # needs to be list because lazy catalog results behave oddly if catalog objects are changed during iteration
        topic=topic_md.getObject()
        if topic:
            topic_parent=topic.aq_inner.aq_parent
            print 'deleting: ', topic.id
            topic_parent.manage_delObjects([topic.id])
        try:
            pc.uncatalog_object(topic_md.data_record_id_)               
        except KeyError:
            print 'tried to uncatalog object but failed'


def setupRemoteLeMills(self, portal):
    #If variable set, tries to add REMOTE_SERVERS to be included in LeMill searches
    search_tool=getToolByName(portal, 'lemill_search')
    remote_boxes=search_tool.get_remote_lemilles()
    for box in REMOTE_SERVERS:
        add = 1
        for r in remote_boxes.values():
            if box == r['URL']:
                add = 0
        if add:
            search_tool.setNewLocation(box)


def setupCleanDuplicateActions(self, portal):
    # Migrating Plone or LeMill causes duplication of certain actions. This is Plone's fault.
    # addNewActions in Plone's ConfigurationMethods creates these actions without checking if they already exist.
    atool=getToolByName(portal, 'portal_actions')
    acts = atool._cloneActions()
    clean_acts=[]
    home_check = ownership_check = rename_check = paste_check = delete_check = cut_check = copy_check = 0
    # Go through actions and add only first instances of the following actions to the new actions list:
    for a in acts:
        if a.getId()=='index_html': #'Home'
            if home_check==0:
                home_check=1
                clean_acts.append(a)
        elif a.getId()=='change_ownership':
            if ownership_check==0:
                ownership_check=1
                clean_acts.append(a)
        elif a.getId()=='rename':
            if rename_check==0:
                rename_check=1
                clean_acts.append(a)
        elif a.getId()=='paste':
            if paste_check==0:
                paste_check=1
                clean_acts.append(a)
        elif a.getId()=='cut':
            if cut_check==0:
                copy_check=1
                clean_acts.append(a)
        elif a.getId()=='copy':
            if copy_check==0:
                copy_check=1
                clean_acts.append(a)
        elif a.getId()=='delete':
            if delete_check==0:
                delete_check=1
                clean_acts.append(a)
        else:
            clean_acts.append(a)
    atool._actions = tuple( clean_acts )
    

def setupFactoryTypes(self, portal):
    """ set types that should use portal_factory """
    ft = getToolByName(portal, 'portal_factory')
    types_list = ft.getFactoryTypes()
    for t in ALL_CONTENT_TYPES:
        types_list[t] = 1
    ft.manage_setPortalFactoryTypes(None, types_list)


# Still missing: ['nl','sl']

def setupLanguageTool(self, portal):
    """ configure plone language tool to use browser language request negotation """
    lt = getToolByName(portal, 'portal_languages')
    if lt is None:
        return
    lt.manage_setLanguageSettings('en', #default language
            AVAILABLE_TRANSLATIONS, # supported languages (needs to be a list, not a tuple)
            1, # use cookie negotiation
            1, # use request negotiation
            0, # use path negotiation
            0, # force language URLs (content)
            1, # allow fallback (content)
            1, # use combined languages
            0, # display flags
            0, # start neutral (content)
            )

# TODO: when we get too many translations, we'll need to shorten the primary list
primary_language_list = AVAILABLE_TRANSLATIONS

def setupProperties(self, portal):
    lt = getToolByName(portal, 'lemill_tool')
    if not hasattr(lt, 'portal_integration'):
        safeEditProperty(lt, 'portal_integration', value=False, data_type="boolean")
    if not hasattr(lt, 'portal_search_link'):
        safeEditProperty(lt, 'portal_search_link', value="TODO", data_type="string")
    if not hasattr(lt, 'primary_languages'):
        safeEditProperty(lt, 'primary_languages', value=primary_language_list, data_type="tokens")
    if not hasattr(lt, 'allow_banning'):
        safeEditProperty(lt, 'allow_banning', value=False, data_type="boolean")
    if not hasattr(lt, 'irc_link'):
        safeEditProperty(lt, 'irc_link', value='http://neumann.uiah.fi/irc/irc.cgi', data_type="string")
    lt.language_dict=dict(LANGUAGES)
    safeEditProperty(portal, 'validate_email', value=False, data_type="boolean")
    
def setupLeMillFAQ(self, portal):
    # Create MultimediaMaterial resource lemill-faq based on docs/FAQ.html
    faqid='lemill-faq'
    context=portal.content.webpages
    if not hasattr(context, faqid):
        addObject(context, faqid, 'MultimediaMaterial', 'LeMill FAQ')
    else:
        return 1 # If there is a lemill_faq don't overwrite it, because we don't want to lose community's changes
    faq=getattr(context, faqid)    
    homedir=package_home(globals())
    file=open(homedir+'/docs/FAQ.html', 'r').read()
    title=file[file.find('<title>')+7:file.rfind('</title>')]
    body=file[file.find('<body>')+6:file.rfind('</body>')]
    faq.edit(title=title, bodyText=body, language='en', tags=['faq', 'lemill'])
    faq.manage_afterAdd(faq,context)
    faq.at_post_create_script()
    faq.state = 'public'
    faq.reindexObject()

def setupLeMillAbout(self, portal):
    # Create MultimediaMaterial resuurce about-lemill based on docs/About.html
    aboutid='about-lemill'
    context=portal.content.webpages
    if not hasattr(context, aboutid):
        addObject(context, aboutid, 'MultimediaMaterial', 'About LeMill')
    else:
        return 1 # If there is a about-lemill don't overwrite it
    about=getattr(context, aboutid)
    homedir=package_home(globals())
    file=open(homedir+'/docs/About.html', 'r').read()
    title=file[file.find('<title>')+7:file.rfind('</title>')]
    body=file[file.find('<body>')+6:file.rfind('</body>')]
    about.edit(title=title, bodyText=body, language='en', tags=['about', 'lemill'])
    about.manage_afterAdd(about,context)
    about.at_post_create_script()
    about.state = 'public'
    about.reindexObject()
    #about.manage_permission(MODIFY_CONTENT, ('Manager','Owner'), acquire=0)
        
def setupUnassignedDiscussionsGroup(self, portal):
    # Create empty group to hold discussions for items not assigned to any group.
    
    if not hasattr(portal, 'community'):
        return 1 
    parent=portal.community.groups
    if hasattr(parent, 'unassigned_discussions'):
        return 1
    # We force our way through stupid allowed-content-types-limitations
    if 'Large Plone Folder' not in parent.allowed_content_types:
        parent.allowed_content_types=parent.allowed_content_types+('Large Plone Folder',)
    if parent.filter_content_types==True:
        parent.filter_content_types=False
    addObject(parent, 'unassigned_discussions', 'Large Plone Folder', 'Discussions for resources not assigned to groups') 
    obj=parent.unassigned_discussions
    syn_tool = getToolByName(portal, 'portal_syndication', None)
    syn_tool.enableSyndication(obj)
    obj.manage_permission(ADD_CONTENT_PERMISSION, ('Member',), acquire=1) 
    obj.manage_permission(LIST_FOLDER_CONTENTS, ('Member',), acquire=1)

    
        

#########
# Collect all setup functions into a setup widget

afunctions = {}
for f in dir():
    if f.startswith('setup'):
        func = eval("%s" % f)
        if type(func) == types.FunctionType:
            afunctions[f] = func

class LeMillSetup(SetupWidget):
    type = 'LeMill Setup'

    description = """Customization methods needed by the LeMill Plone portal"""

    functions = afunctions

    def setup(self):
        pass

    def delItems(self, fns):
        out = []
        out.append(('Currently there is no way to remove a function', INFO))
        return out

    def addItems(self, fns):
        """This method is called when configuration methods need to be applied.
        fns is the list of function names that need to be executed in order."""
        out = []
        for fn in fns:
            # All functions are executed with the portal as the first actual parameter
            self.functions[fn](self, self.portal)
            out.append(('Function %s has been applied' % fn, INFO))
        return out

    def installed(self):
        return []

    def available(self):
        """Get a list of availabel functions."""
        funcs = self.functions.keys()
        # Sort, so we get a pre-determined order.
        # The functions need to be named properly
        funcs.sort()
        return funcs