def testMigration(self): self.createLinguaPloneStructure() migration_view = getMultiAdapter((self.portal, self.request), name='migration-view') migration_view() self.assertEqual(ITranslationManager(self.doc1).get_translations(), {'ca': self.doc1_ca, 'en': self.doc1, 'es': self.doc1_es}) self.assertEqual(ITranslationManager(self.folder).get_translations(), {'ca': self.folder_ca, 'en': self.folder, 'es': self.folder_es}) self.assertEqual(ITranslationManager(self.doc2).get_translations(), {'ca': self.doc2_ca, 'en': self.doc2, 'es': self.doc2_es}) self.assertEqual(ITranslationManager(self.doc3).get_translations(), {'ca': self.doc3, 'es': self.doc3_es}) self.assertEqual(ITranslationManager(self.doc4).get_translations(), {'en': self.doc4_en, 'es': self.doc4})
def _get_translations_by_dialog(self, supported_langs): """ """ context = aq_inner(self.context) default_view_for = getMultiAdapter((context, self.request), name='plone_context_state').canonical_object() _checkPermission = getSecurityManager().checkPermission translations = {} if ISiteRoot.providedBy(context): # We have a site root, which works as a fallback for code in supported_langs: has_view_permission = bool(_checkPermission('View', context)) translations[code] = (context, True, has_view_permission) elif INavigationRoot.providedBy(default_view_for): for code, content in ITranslationManager(default_view_for).get_translations().items(): code = str(code) has_view_permission = bool(_checkPermission('View', content)) translations[code] = (content, True, has_view_permission) else: for code, content in ITranslationManager(context).get_translations().items(): code = str(code) has_view_permission = bool(_checkPermission('View', content)) translations[code] = (content, True, has_view_permission) return translations
def test_move_content_proper_language_folder_existing_translation_inside( self): self.assertTrue(getattr(self.portal, 'en')) self.portal.en.invokeFactory('Folder', 'new11', title=u"An archetypes based folder") new11 = self.portal.en['new11'] new11.invokeFactory('Document', 'doc11', title=u"An archetypes based doc") doc1_ca = makeTranslation(self.portal.en.new11.doc11, 'ca') doc1_ca.edit(title="Foo", language='ca') self.assertTrue(self.portal.ca.doc11) transaction.commit() # Change the content language of the created folder to 'ca' multilingualMoveObject(new11, 'ca') self.assertTrue(self.portal.ca.new11) self.assertTrue(self.portal.ca.new11.doc11) self.assertEqual( ITranslationManager(self.portal.ca.new11.doc11).get_translations(), {'ca': self.portal.ca.new11.doc11}) self.assertEqual( ITranslationManager(doc1_ca).get_translations(), {'ca': doc1_ca}) self.assertEqual(ILanguage(self.portal.ca.new11).get_language(), 'ca') self.assertEqual( ILanguage(self.portal.ca.new11.doc11).get_language(), 'ca')
def handle_modified(self, content): fieldmanager = ILanguageIndependentFieldsManager(content) if not fieldmanager.has_independent_fields(): return sm = getSecurityManager() try: # Do we have permission to sync language independent fields? if self.bypass_security_checks(): # Clone the current user and assign a new editor role to # allow edition of all translated objects even if the # current user whould not have permission to do that. tmp_user = UnrestrictedUser( sm.getUser().getId(), '', ['Editor', ], '') # Wrap the user in the acquisition context of the portal # and finally switch the user to our new editor acl_users = getToolByName(content, 'acl_users') tmp_user = tmp_user.__of__(acl_users) newSecurityManager(None, tmp_user) # Copy over all language independent fields transmanager = ITranslationManager(content) for translation in self.get_all_translations(content): # PATCHED CODE HERE trans_obj = transmanager.get_restricted_translation(translation) if trans_obj: if fieldmanager.copy_fields(trans_obj): self.reindex_translation(trans_obj) # END PATCHED CODE finally: # Restore the old security manager setSecurityManager(sm)
def __call__(self): pc = getToolByName(self.context, 'portal_catalog') pl = getToolByName(self.context, 'portal_languages') self.results = [] for language_supported in pl.getSupportedLanguages(): translated_objects = pc.searchResults( object_provides=LP_TRANSLATABLE, Language=language_supported) for brain in translated_objects: obj = brain.getObject() if obj.isCanonical(): translations = obj.getTranslations(include_canonical=False) manager = ITranslationManager(obj) if translations: for language in translations.keys(): try: manager.register_translation( language, translations[language][0]) except KeyError: logger.warning( '%s already translated to %s: %s' % (obj.id, language, str(manager.get_translations()))) self.results.append(manager.get_translations()) return self.template()
def __init__(self, context, request): self.context = context self.request = request portal_state = getMultiAdapter((context, request), name="plone_portal_state") self.portal_url = portal_state.portal_url() self.group = ITranslationManager(self.context)
def render(self): cat = getToolByName(self.context, 'portal_catalog') query = dict(portal_type='Folder', Language='en') res = cat(query) log.info('Total no. of folders found: {0}'.format(len(res))) links = dict() for r in res: if r.getPath().split('/')[2] != 'en': log.warning( "Found a folder with lang EN not under /en: {0}".format( r.getPath())) continue obj = r.getObject() if not ITranslatable.providedBy(obj): log.warning( 'Found a folder that is not translatable, WTF: {0}'.format( r.getPath())) continue tm = ITranslationManager(obj) log.info('Handling folder {0}.'.format('/'.join( obj.getPhysicalPath()))) for lang, trans in tm.get_translations().items(): if lang == 'en': continue # Copy "Exclude from navigation", section images and related sites trans.exclude_from_nav = obj.exclude_from_nav rsl = IRelatedSites(trans).related_sites_links if len(rsl): links['/'.join(trans.getPhysicalPath())] = rsl return json.dumps(links)
def __call__(self): if (self.request.method != 'POST' and not ('field' in self.request.form.keys() and 'lang_source' in self.request.form.keys())): return _("Need a field") else: manager = ITranslationManager(self.context) registry = getUtility(IRegistry) settings = registry.forInterface(IMultiLanguageExtraOptionsSchema) lang_target = ILanguage(self.context).get_language() lang_source = self.request.form['lang_source'] orig_object = manager.get_translation(lang_source) try: question = orig_object.getField( self.request.form['field']).get(orig_object) except AttributeError: return _("Invalid field") if len(question) > 1600: return _("Too long field") data = { 'key': settings.google_translation_key, 'target': lang_target, 'source': lang_source, 'q': question } params = urllib.urlencode(data) url = 'https://www.googleapis.com/language/translate/v2' retorn = urllib.urlopen(url + '?' + params) return retorn.read()
def handle_unlink(self, action): data, errors = self.extractData() manager = ITranslationManager(self.context) if not errors: for language in data['languages']: manager.remove_translation(language) return self.request.response.redirect(self.context.absolute_url() \ + '/remove_translations')
def __getattr__(self, uuid): site = getSite() brains = site.portal_catalog(UID=uuid, Language='all') if not brains: raise AttributeError(uuid) obj = brains[0].getObject() return Translation(ITranslationManager(obj))
def idiomesIndexer(obj): llistat = [] manager = ITranslationManager(obj) translations = manager.get_translations() for translation in translations: formula = translations[translation] for i in formula.items(): llistat.append(i[1].Title()) return llistat
def linkTranslations(self): """ Links the translations of the default language Folders """ doneSomething = False try: canonical = ITranslationManager(self.folders[self.defaultLanguage]) except TypeError, e: raise TypeError(str(e) + " Are your folders ITranslatable?")
def _translations(self, missing): # Figure out the "closest" translation in the parent chain of the # context. We stop at both an INavigationRoot or an ISiteRoot to look # for translations. We do want to find something that is definitely # in the language the user asked for. context = aq_inner(self.context) translations = {} chain = aq_chain(context) first_pass = True _checkPermission = getSecurityManager().checkPermission for item in chain: if ISiteRoot.providedBy(item): # We have a site root, which works as a fallback has_view_permission = bool(_checkPermission('View', item)) for c in missing: translations[c] = (item, first_pass, has_view_permission) break elif IFactoryTempFolder.providedBy(item) or \ IFactoryTool.providedBy(item): # TempFolder or portal_factory, can't have a translation continue canonical = ITranslationManager(item, None) item_trans = canonical.get_translations() for code, trans in item_trans.items(): code = str(code) if code not in translations: # make a link to a translation only if the user # has view permission has_view_permission = bool(_checkPermission('View', trans)) if (not INavigationRoot.providedBy(item) and not has_view_permission): continue # If we don't yet have a translation for this language # add it and mark it as found translations[code] = (trans, first_pass, has_view_permission) missing = missing - set((code, )) if len(missing) <= 0: # We have translations for all break if INavigationRoot.providedBy(item): # Don't break out of the navigation root jail has_view_permission = bool(_checkPermission('View', item)) for c in missing: translations[c] = (item, False, has_view_permission) break first_pass = False # return a dict of language code to tuple. the first tuple element is # the translated object, the second argument indicates wether the # translation is a direct translation of the context or something from # higher up the translation chain return translations
def test_multilingual_content_is_linked(self): english_content = self.portal.get('en').get('accessibility') self.assertTrue(english_content, 'Missing page /en/accessibility') german_content = self.portal.get('de').get('barrierefreiheit') self.assertTrue(german_content, 'Missing page /de/barrierefreiheit') manager = ITranslationManager(english_content) self.assertEquals(german_content, manager.get_translation('de'), 'English and German content should be linked.')
def handle_remove(self, action): data, errors = self.extractData() manager = ITranslationManager(self.context) if not errors: for language in data['languages']: content = manager.get_translation(language) manager.remove_translation(language) aq_parent(content).manage_delObjects([content.getId()]) return self.request.response.redirect(self.context.absolute_url() \ + '/remove_translations')
def temesIndexer(obj): resultat = [] temes = obj.temes for tema in temes: tema_obj = tema.to_object manager = ITranslationManager(tema_obj) translations = manager.get_translations() for translation in translations: resultat.append(translations[translation].id) return resultat
def handle_add(self, action): data, errors = self.extractData() if not errors: content = data['content'] language = data['language'] ITranslationManager(self.context).register_translation(language,\ content) ILanguage(content).set_language(language) return self.request.response.redirect(self.context.absolute_url()\ + '/add_translations')
def set_recursive_language(obj, language): """ Set the language at this object and recursive """ if ILanguage(obj).get_language() != language: ILanguage(obj).set_language(language) ITranslationManager(obj).update() reindex_object(obj) if IFolderish.providedBy(obj): for item in obj.items(): if ITranslatable.providedBy(item): set_recursive_language(item, language)
def translated_urls(context): manager = ITranslationManager(context) translated_languages = manager.get_translated_languages() content_language = ILanguage(context).get_language() if content_language in translated_languages: translated_languages.remove(content_language) languages = [] for lang in translated_languages: languages.append(SimpleVocabulary.createTerm(lang, lang, \ manager.get_translation(lang).absolute_url())) return SimpleVocabulary(languages)
def get_all_translations(self, content): """Return all translations excluding the just modified content""" translations_list_to_process = [] content_lang = queryAdapter(content, ILanguage).get_language() canonical = ITranslationManager(content) translations = canonical.get_translations() for language in translations.keys(): if language != content_lang: translations_list_to_process.append(translations[language]) return translations_list_to_process
def getAlbumContent(self, container=None, images=0, folders=0, subimages=0, others=0): """ Mostly ripped out from atctListAlbum.py """ if not container: container = self.context # language fallback default_lang = api.portal.get_tool( "portal_languages").getDefaultLanguage() if container.Language() != default_lang: container = ITranslationManager(container).get_translation( default_lang) contents = container.objectValues() result = {} if images: result['images'] = [ x for x in contents if x.portal_type == 'Image' ] if folders: result['folders'] = [ x for x in contents if x.portal_type == 'Folder' ] if subimages: # in this case, container is a sub-folder of the main photo gallery result['subimages'] = [ x for x in contents if x.portal_type == 'Image' ] # if others: # utils = getToolByName(self.context, 'plone_utils') # searchContentTypes = utils.getUserFriendlyTypes() # filtered = [p_type for p_type in searchContentTypes # if p_type not in ('Image', 'Folder',)] # if filtered: # # We don't need the full objects for the folder_listing # result['others'] = container.getFolderContents( # {'portal_type': filtered}) # else: # result['others'] = () result['others'] = () return result
def createdEvent(obj, event): """ It can be a IObjectRemovedEvent - don't do anything IObjectMovedEvent IObjectAddedEvent IObjectCopiedEvent """ if IObjectRemovedEvent.providedBy(event): return portal = getSite() language_tool = getToolByName(portal, 'portal_languages') # On ObjectCopiedEvent and ObjectMovedEvent aq_parent(event.object) is # always equal to event.newParent. parent = aq_parent(event.object) if (language_tool.startNeutral() and ITranslatable.providedBy(obj)): # We leave this untouched by now. # We don't set languages set_recursive_language(obj, LANGUAGE_INDEPENDENT) elif (IPloneSiteRoot.providedBy(parent) and ITranslatable.providedBy(obj) and ILanguage(obj).get_language() == LANGUAGE_INDEPENDENT): # It's a root folder and we set the default language # ( not independent allowed ) language = language_tool.getPreferredLanguage() set_recursive_language(obj, language) elif ITranslatable.providedBy(parent): # Normal use case # We set the tg, linking language = ILanguage(parent).get_language() set_recursive_language(obj, language) sdm = obj.session_data_manager session = sdm.getSessionData() if 'tg' in session.keys() and \ not portal.portal_factory.isTemporary(obj): IMutableTG(obj).set(session['tg']) old_obj = ITranslationManager(obj).get_translation( session['old_lang']) # Copy ILanguage Independent field on on-the-fly translation cloner = ITranslationCloner(old_obj) cloner(obj) reindex_object(obj) del session['tg']
def deletable_languages(context): manager = ITranslationManager(context) translated_languages = manager.get_translated_languages() language_tool = getToolByName(context, 'portal_languages') language_infos = language_tool.getAvailableLanguages() content_language = ILanguage(context).get_language() languages = [] for lang in translated_languages: if lang not in content_language: native = language_infos[lang].get('native', None) name = language_infos[lang].get('name', lang) languages.append(SimpleVocabulary.createTerm(lang, lang, \ native or name)) return SimpleVocabulary(languages)
def __call__(self, language): """ Look for the closest translated folder or siteroot """ parent = aq_parent(self.context) translated_parent = parent found = False while not IPloneSiteRoot.providedBy(parent) and not found: parent_translation = ITranslationManager(parent) if parent_translation.has_translation(language): translated_parent = parent_translation.get_translation( language) found = True parent = aq_parent(parent) return translated_parent
def getTemes(self): ltool = getToolByName(self.context, 'portal_languages') languages = ltool.getAvailableLanguageInformation() temes = self.context.temes resultat = [] for tema in temes: obj = tema.to_object manager = ITranslationManager(obj) translations = manager.get_translations() if self.context.language in translations: tema_idioma = translations[self.context.language] resultat.append({ 'url': tema_idioma.absolute_url, 'titol': tema_idioma.title }) return resultat
def eguides(self): obj = self.context eguides = [] if obj.Language() != 'en': obj = ITranslationManager(obj).get_translation('en') for item in obj.eguides: eguide = {} eguide['country'] = COUNTRIES[item['country']] eguide['flagname'] = eguide['country'].lower().replace(" ", "_") eguide['online'] = obj.online_version_url.format( country=item['country'], language=item['language'].upper()) eguide['offline'] = obj.offline_version_url.format( country=item['country'], language=item['language'].upper()) eguide['language'] = item['language'] eguides.append(eguide) eguides = sorted(eguides, key=lambda a: a['country'] + a['language']) return eguides
def untranslated_languages(context): language_tool = getToolByName(context, 'portal_languages') language_infos = language_tool.getAvailableLanguages() default_language = language_tool.getDefaultLanguage() available_portal_languages = language_tool.supported_langs manager = ITranslationManager(context) translated_languages = manager.get_translated_languages() content_language = ILanguage(context).get_language() filter_default = (content_language == LANGUAGE_INDEPENDENT) languages = [] for lang in available_portal_languages: if lang not in translated_languages: native = language_infos[lang].get('native', None) name = language_infos[lang].get('name', lang) languages.append(SimpleVocabulary.createTerm(lang, lang, \ native or name)) return SimpleVocabulary(languages)
def get_all_events(self, batch=True): # Fall back to default language for local events kw = {} default_lang = api.portal.get_tool( "portal_languages").getDefaultLanguage() if ITranslatable.providedBy(self.context): if default_lang != self.context.Language(): portal = getSite() trans = ITranslationManager( self.context).get_translation(default_lang) root = getNavigationRootObject(trans, portal) kw['path'] = '/'.join(root.getPhysicalPath()) kw['Language'] = [default_lang, ''] start, end = self._start_end sort = 'start' sort_reverse = False if self.mode in ('past', 'all'): sort_reverse = True expand = True local_events = get_events(self.context, start=start, end=end, sort=sort, review_state='published', sort_reverse=sort_reverse, ret_mode=RET_MODE_ACCESSORS, expand=expand, **kw) remote_events = self._remote_events() reverse = self.mode == 'past' all_events = sorted(local_events + remote_events, key=lambda x: x.start, reverse=reverse) if batch: b_start = self.b_start b_size = self.b_size res = Batch(all_events, size=b_size, start=b_start, orphan=self.orphan) else: res = all_events return res
def __call__(self): if (self.request.method != 'POST' and not ('field' in self.request.form.keys() and 'lang_source' in self.request.form.keys())): return _("Need a field") else: manager = ITranslationManager(self.context) registry = getUtility(IRegistry) settings = registry.forInterface(IMultiLanguageExtraOptionsSchema) lang_target = ILanguage(self.context).get_language() lang_source = self.request.form['lang_source'] orig_object = manager.get_translation(lang_source) try: question = orig_object.getField( self.request.form['field']).get(orig_object) except AttributeError: return _("Invalid field") return google_translate(question, settings.google_translation_key, lang_target, lang_source)
def handle_modified(self, content): canonical = ITranslationManager(content).query_canonical() if canonical in self.stack: return else: self.stack.append(canonical) # Copy over all language independent fields translations = self.get_all_translations(content) manager = ILanguageIndependentFieldsManager(content) for translation in translations: manager.copy_fields(translation) # fti = getUtility(IDexterityFTI, name=content.portal_type) # schema = fti.lookupSchema() schema = content.Schema() descriptions = Attributes(schema) self.reindex_translations(translations, descriptions) self.stack.remove(canonical)