migrate I18NFolders

setuplanguages.py

from Products.CMFCore.utils import getToolByName
from Acquisition import aq_parent, aq_inner

def setup(self):
    result = []
    setterupper = SetupFolders(self)
    result.extend(setterupper.setup())
    result.extend(setterupper.dfs(self))
    result.extend(setterupper.linkGlobalTranslations())
    return '\n'.join(result)

class SetupFolders(object):
    def __init__(self, context):
        self.previousDefaultPageId = None
        self.context = context
        self.request = context.REQUEST
        self.portal_languages = getToolByName(self.context, "portal_languages")
        self.plone_utils = getToolByName(self.context, "plone_utils")

    def setup(self):
        result = []
        self.folders = {}
        self.translationsToBeLinked = []
        pl = getToolByName(self.context, "portal_languages")
        self.languages = languages = pl.getSupportedLanguages()
        if len(languages) == 1:
            return 'Only one supported language configured.'
        self.defaultLanguage = pl.getDefaultLanguage()
        available = pl.getAvailableLanguages()
        for language in languages:
            native = available[language]
            result.extend(self.setUpLanguage(language, native))
        result.extend(self.linkTranslations())
        # result.extend(self.removePortalDefaultPage())
        # if self.previousDefaultPageId:
            # result.extend(self.resetDefaultPage())
        # result.extend(self.setupLanguageSwitcher())
        if not result:
            return ["Nothing done."]
        else:
            result.insert(0, "Setup of language root folders on Plone site "
                "'%s'" % self.context.getId())
            return result

    def linkTranslations(self):
      result = []
      doneSomething = False
      canonical = self.folders.get(self.defaultLanguage)
      for language in self.languages:
          if ((language != self.defaultLanguage) and
              (canonical is not None) and 
              (not canonical.hasTranslation(language)) and 
              (self.folders.get(language) is not None)):
              self.folders[language].addTranslationReference(canonical)
              doneSomething = True
      if doneSomething:
          result.append("Translations linked.")
      return result

    def linkGlobalTranslations(self):
      result = []
      for obj in self.translationsToBeLinked:
          self.folders = {}
          for lang in obj.keys():
              self.folders[lang] = self.context.unrestrictedTraverse(obj[lang])
          self.linkTranslations()
      return result

    def setUpLanguage(self, code, name):
        result = []
        folderId = "%s" % code
        folder = getattr(self.context, folderId, None)
        wftool = getToolByName(self.context, 'portal_workflow')
        if folder is None:
            self.context.invokeFactory('Folder', folderId)
            folder = getattr(self.context, folderId)
            folder.setLanguage(code)
            folder.setTitle(name)
            state = wftool.getInfoFor(folder, 'review_state', None)
            # This assumes a direct 'publish' transition from the initial state
            if state != 'published':
                wftool.doActionFor(folder, 'publish')
            folder.reindexObject()
            result.append("Added '%s' folder: %s" % (code, folderId))
        self.folders[code] = folder
        # if not INavigationRoot.providedBy(folder):
        #     alsoProvides(folder, INavigationRoot)
        #     result.append("INavigationRoot setup on folder '%s'" % code )
        return result

    def removePortalDefaultPage(self):
        result = []
        defaultPageId = self.context.getDefaultPage()
        if not defaultPageId:
            return result
        self.previousDefaultPageId = defaultPageId
        self.context.setDefaultPage(None)
        self.context.reindexObject()
        result.append('Portal default page removed.')
        return result

    def resetDefaultPage(self):
        result = []
        previousDefaultPage = getattr(self.context, self.previousDefaultPageId)
        language = previousDefaultPage.Language()
        pageId = self.previousDefaultPageId
        # test language neutral
        if language == '':
            language = self.defaultLanguage
        target = self.folders[language]
        objects = self.context.manage_cutObjects(pageId)
        target.manage_pasteObjects(objects)
        target.setDefaultPage(pageId)
        target.reindexObject()
        defaultPage = getattr(target, pageId)
        defaultPage.reindexObject()
        result.append("Moved default page '%s' to folder '%s'." %
            (pageId, target.getId()))
        return result

    def dfs(self, context, prefix=''):
        result = []
        foldertypes = ['Folder', 'I18NFolder']
        catalog = getToolByName(context, 'portal_catalog')
        path = '/'.join(context.getPhysicalPath())
        already_visited = ['events', 'news', 'Members', 'welcome', 'en', 'fr', 'es', 'ar', 'images-for-site']
        self.single_languages = { 'admin-dashboard': [ 'en', ],
                                  'French': [ 'fr', ],
                                  'Spanish': [ 'es', ],
                                  'Arabic': [ 'ar', ]}
        query = {'Language': 'all', 'path': {'query': path, 'depth': 1}}
        search = catalog.searchResults(query)
        for brain in search:
            id = brain.getId
            obj = brain.getObject()
            ptype = brain.portal_type
            lang = brain.Language
            if brain.portal_type in foldertypes:
                if id not in already_visited:
                    already_visited.append(id)
                    localprefix = prefix
                    if ptype in foldertypes:
                        localprefix = prefix + '+ '
                    translations = ''
                    if obj.isTranslation():
                        try:
                            translations = obj.getTranslationLanguages()
                        except AttributeError:
                            pass
                    result.append("%s%s (%s) (%s) (%s)" % 
                            (localprefix, id, ptype, lang, translations))
                    result.extend(self.mirror_folders(obj))
                    if brain.portal_type in foldertypes:
                        dfs = self.dfs(obj, '\t')
                        if dfs:
                            result.append(prefix + ('\n' + prefix).join( dfs ))
            
        return result
    
    def mirror_folders(self, context):
        result = []
        self.folders = {}
        self.default_pages = {}
        for language in self.languages:
             result.extend(self.mirror_folder_for_language(context,language))
             # result.extend(self.mirror_default_page_for_language(context,language))
        self.find_default_pages(context)
        result.extend(self.linkTranslations())
        result.extend(self.postponeLinkingTranslations(context))
        return result

    def postponeLinkingTranslations(self, context):
        result = []
        tobelinked = {}
        translations = context.getTranslations()
        if (context.portal_type == 'Folder' and len(translations) > 1):
            for lang in translations.keys():
                newlang = lang
                if lang == '': newlang = self.defaultLanguage
                obj = translations[lang][0]
                path_list = list(obj.getPhysicalPath())
                path_list.insert(2, newlang)
                path = '/'.join(path_list)
                tobelinked[newlang] = path
                result.append("Added path %s for %s to be linked later." 
                              % (path, newlang))
            self.translationsToBeLinked.append(tobelinked)
        return result
        
    def find_default_pages(self, context):
        result = []
        default_pages = []
        containerid = context.getId()
        doneSomething = False
        
        if context.portal_type != 'I18NFolder':
            pass
            # print context
            # print context.getDefaultPage()
            # print context.getTranslations()
            # print context.Language()
            # if context.getDefaultPage():
            #     print getattr(context, context.getDefaultPage()).getTranslations()
            # print "--------------------------"
        else:
            print context
            print context.getDefaultPage()
            print context.getTranslations()
            print context.Language()
            if context.getDefaultPage():
                print getattr(context, context.getDefaultPage()).getTranslations()
            print "--------------------------"
            catalog = getToolByName(context, 'portal_catalog')
            path = '/'.join(context.getPhysicalPath())
            query = {'path': {'query': path, 'depth': 1}, 
                    'is_default_page': True,
                    'Language': 'all'}
            search = catalog.searchResults(query)
    
            potential_default_pages = [b.getId for b in search]
            translation_langs = context.getTranslationLanguages()
    
            default_langs = []
            for brain in search:
                if brain.Language not in default_langs:
                    default_langs.append(brain.Language)
    
            if (context.getDefaultPage() == None and len(search) == 0):
                return

            # if len(default_langs) != len(translation_langs):
            #     import pdb ; pdb.set_trace( )
        
            # if (context.getDefaultPage() == None and len(search) > 0):
            #     import pdb ; pdb.set_trace( )
            # 
            # if len(search) > len(default_langs):
            #     import pdb ; pdb.set_trace( )
                
            # if '' not in default_langs and 'en' not in default_langs:
                # import pdb ; pdb.set_trace( )

            path = '/'.join(context.getPhysicalPath())
            path = path + '/' + context.getDefaultPage()
            one_default_page = self.context.unrestrictedTraverse(path)
            for lang in translation_langs:
                # import pdb ; pdb.set_trace( )
                templang = lang
                if ((lang == '') and ('' in translation_langs)):
                    templang = self.defaultLanguage
                if ((containerid not in self.single_languages.keys()) or
                    (templang in self.single_languages[containerid])) :
                    if lang in default_langs:
                        translation = one_default_page.getTranslation(lang)
                        if not translation: import pdb ; pdb.set_trace( )
                    else:
                        translation = one_default_page.getCanonical()
                    
                    lang = templang
                    if translation:
                        defaultPageId = translation.getId()
                        target = self.folders[lang]
                        objects = context.manage_copyObjects(defaultPageId)
                        target.manage_pasteObjects(objects)
                        target.setDefaultPage(defaultPageId)
                        target.reindexObject()
                        defaultPage = getattr(target, defaultPageId)
                        defaultPage.reindexObject()
                        result.append("Moved default page '%s' to folder '%s." %
                            (defaultPageId, target.getId()))
                        self.default_pages[lang] = defaultPage
            
            canonical = self.default_pages.get(self.defaultLanguage)
            # import pdb ; pdb.set_trace( )
            for lang in translation_langs:
                templang = lang
                if ((lang == '') and ('' in translation_langs)):
                    templang = self.defaultLanguage
                if ((containerid not in self.single_languages.keys()) or
                    (templang in self.single_languages[containerid])) :
                    if ((templang != self.defaultLanguage) and
                        (canonical is not None) and 
                        (not canonical.hasTranslation(templang)) and 
                        (self.default_pages.get(templang) is not None)):
                        self.default_pages[templang].addTranslationReference(canonical)
                        doneSomething = True
            if doneSomething:
                result.append("Translations linked.")
            return result
                    
                    
                    
                    
        # 
        # for lang in translation_langs:
        #     for brain in search:
        #         if brain.Language == lang:
        #             obj = brain.getObject()
        #             for lang2 in translation_langs:
        #                 translation = obj.getTranslation(lang)
        #                 if translation.getId() not in potential_default_pages:
        #     
        # for brain in search:
        #     if brain.getId in potential_default_pages:
        #         obj = brain.getObject()
        #         for lang in translation_langs:
        #             if obj.getTranslation(lang).getId() not in potential_default_pages:
        #                 import pdb ; pdb.set_trace( )
        #                 break
                    
        # for brain in search:
        # for obj in context.objectValues():
        #     if self.plone_utils.isDefaultPage(obj, True):
        #         default_pages.append(obj)
        # 
        # for obj in default_pages:
        #     lang = obj.Language()
        #     self.checkLanguages([lang,])
        #     self.default_pages[lang] = obj.getId()
        
    def mirror_default_page_for_language(self, context, lang):
        result = []
        containerid = context.getId()
        if ((containerid not in self.single_languages.keys()) or
            (lang in self.single_languages[containerid])) :
            thislangs = context.getTranslationLanguages()
            result.append(self.checkLanguages(thislangs))
            templang = lang
            if ((templang == self.defaultLanguage) and ('' in thislangs)):
                templang = None

            # catalog = getToolByName(context, 'portal_catalog')
            # path = '/'.join(context.getPhysicalPath())
            # query = {'path': {'query': path, 'depth': 1}}
            # if templang: query['Language'] = templang
            # search = catalog.searchResults(query)
            # defaultPageId = None
            # # if (containerid == 'about-fghr' and lang == 'es'):
            # #     import pdb ; pdb.set_trace( )
            # for brain in search:
            #     if self.plone_utils.isDefaultPage(brain.getObject()):
            #         defaultPageId = brain.getId

            
            translation = context.getTranslation(templang)
            if translation:
                defaultPageId = translation.getDefaultPage()
            else:
                defaultPageId = context.getDefaultPage()
            
            # if defaultPageId:
            #     target = self.folders[lang]
            #     objects = context.manage_cutObjects(defaultPageId)
            #     target.manage_pasteObjects(objects)
            #     target.setDefaultPage(defaultPageId)
            #     target.reindexObject()
            #     defaultPage = getattr(target, defaultPageId)
            #     defaultPage.reindexObject()
            #     result.append("Moved default page '%s' to folder '%s." %
            #         (defaultPageId, target.getId()))
            self.default_pages[lang] = defaultPageId
        return result
        
    def mirror_folder_for_language(self, context, lang):
        result = []
        id = context.getId()
        if ((id not in self.single_languages.keys()) or
            (lang in self.single_languages[id])) :
            
            if context.portal_type == 'Folder':
                if id not in self.single_languages.keys():
                    folderLang = context.Language()
                    if folderLang == '':  folderLang = self.defaultLanguage
                    if folderLang != lang:
                        return result

            path_list = list(context.getPhysicalPath())
            originalpath = '/'.join(path_list[:-1])
            path_list.insert(2, lang)
            targetpath = '/'.join(path_list[:-1])
            targetfolder = self.context.unrestrictedTraverse(targetpath)
            target = getattr(targetfolder.aq_explicit, id, None)
            if target is None:
                targetfolder.invokeFactory('Folder', id)
                target = getattr(targetfolder, id)
                target.setLanguage(lang)

                thislangs = context.getTranslationLanguages()
                result.append(self.checkLanguages(thislangs))
                templang = lang
                if ((lang == self.defaultLanguage) and ('' in thislangs)):
                    templang = None

                title = context.Title()
                desc = context.Description()
                if context.portal_type == 'I18NFolder':
                    title = context.Title(templang)
                    desc = context.Description(templang)
                else:
                    translation = context.getTranslation(templang)
                    if translation:
                        title = translation.Title()
                        desc = translation.Description()
                target.setTitle(title)
                target.setDescription(desc)

                wftool = getToolByName(self.context, 'portal_workflow')
                state = wftool.getInfoFor(context, 'review_state', None)
                if state != 'published' and state != 'private':
                    result.append("**** %s/%s state: %s" % (originalpath, id, state))
                if state == 'published':
                    wftool.doActionFor(target, 'publish')
                if state == 'private':
                    wftool.doActionFor(target, 'hide')
                target.reindexObject()
                result.append("Added '%s' folder: %s" % (lang, id))
            self.folders[lang] = target
        return result
    
    def checkLanguages(self, ctxlangs):
        for lang in ctxlangs:
            if lang not in self.languages + ['']:
                import pdb ; pdb.set_trace( )
                return "##### Unrecognized language: %s" % lang
            return ''
    
    # def setLanguage(self, language):
    #     self.request['set_language'] = language
    #     self.portal_languages.setLanguageBindings()