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 __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 _back_references(source_object, attribute_name, translation=None): catalog = getUtility(ICatalog) intids = getUtility(IIntIds) lang = queryAdapter(source_object, ILanguage).get_language() if translation: lang = queryAdapter(translation, ILanguage).get_language() gsm = getSecurityManager() result = [] for rel in catalog.findRelations({ 'to_id': intids.getId(aq_inner(source_object)), 'from_attribute':attribute_name }): obj = intids.queryObject(rel.from_id) if obj is not None and checkPermission('zope2.View', obj): if ITranslatable.providedBy(obj): trans_manager = ITranslationManager(aq_inner(obj)) try: trans_obj = trans_manager.get_translation(lang) except Unauthorized, e: continue if trans_obj: result.append(trans_obj) continue if gsm.checkPermission('zope2.View', obj): result.append(obj)
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 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 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 _at_back_references(source_object, relationship, translation=None): lang = queryAdapter(source_object, ILanguage).get_language() if translation: lang = queryAdapter(translation, ILanguage).get_language() refs = IReferenceable(source_object).getBRefs(relationship=relationship) gsm = getSecurityManager() result = [] for obj in refs: if ITranslatable.providedBy(obj): trans_manager = ITranslationManager(aq_inner(obj)) try: trans_obj = trans_manager.get_translation(lang) except Unauthorized: continue if trans_obj: result.append(trans_obj) continue if gsm.checkPermission('zope2.View', obj): result.append(obj) return result
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 _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 renamer(ob, *args, **kw): """ rename one object within context from oldid to newid """ err = list() oldid = kw['oldid'] newid = kw['newid'] if not oldid: err.append(u'Current id must not be empty') else: oldid = oldid.encode('utf-8') if not newid: err.append(u'New id must not be empty') else: newid = newid.encode('utf-8') if not err: if oldid not in ob.objectIds(): manager = ITranslationManager(kw['target_object']) trans = manager.get_translation(kw['lang']) if trans: oldid = trans.getId() if oldid in ob.objectIds(): ob.manage_renameObjects([oldid], [newid]) else: err.append( 'No translation for %s in language %s found in ' 'folder %s' % (oldid, kw['lang'], '/'.join(ob.getPhysicalPath()))) return err
def delete_this(ob, *args, **kw): err = list() lang = kw.get('lang', '') id_to_delete = kw['id_to_delete'] name = '' if id_to_delete in ob.objectIds(): name = id_to_delete else: # look for a translation of the item in the current language target_object = kw.get('target_object', None) if target_object: manager = ITranslationManager(target_object) trans_object = manager.get_translation(lang) if trans_object: name = trans_object.getId() if not name: err.append(u'No translation for language %s found' % lang) else: try: ob._delObject(name) except Exception, e: err.append( u'Could not delete %s for language %s. Message: %s' % (id_to_delete, lang, str(e)))
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): 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(str(manager.get_translations())) logger.info("Finished with transferring catalog information") return self.template()
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 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 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 _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 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_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 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 __call__(self): language = self.request.get('language', None) if language: context = aq_inner(self.context) translation_manager = ITranslationManager(context) if ILanguage(context).get_language() == LANGUAGE_INDEPENDENT: # XXX : Why we need this ? the subscriber from pm should maintain it language_tool = getToolByName(context, 'portal_languages') default_language = language_tool.getDefaultLanguage() ILanguage(context).set_language(default_language) translation_manager.update() context.reindexObject() new_parent = translation_manager.add_translation_delegated(language) registry = getUtility(IRegistry) settings = registry.forInterface(IMultiLanguageExtraOptionsSchema) sdm = self.context.session_data_manager session = sdm.getSessionData(create=True) session.set("tg", translation_manager.tg) baseUrl = new_parent.absolute_url() # We set the language and redirect to babel_view or not if settings.redirect_babel_view: # Call the ++addtranslation++ adapter to show the babel add form url = '%s/++addtranslation++%s' % (baseUrl, self.context.portal_type) return self.request.response.redirect(url) else: # We look for the creation url for this content type # Get the factory types_tool = getToolByName(self.context, 'portal_types') # Note: we don't check 'allowed' or 'available' here, because these are # slow. We assume the 'allowedTypes' list has already performed the # necessary calculations actions = types_tool.listActionInfos( object=new_parent, check_permissions=False, check_condition=False, category='folder/add', ) addActionsById = dict([(a['id'], a) for a in actions]) typeId = self.context.portal_type addAction = addActionsById.get(typeId, None) if addAction is not None: url = addAction['url'] if not url: url = '%s/createObject?type_name=%s' % (baseUrl, quote_plus(typeId)) return self.request.response.redirect(url)
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 translate_this( context, attrs=[], translation_exists=False, target_languages=[]): """ Translates the current object into all languages and transfers the given attributes """ info = list() warnings = list() errors = list() # if context is language-neutral, it must receive a language before # it is translated lang_support = ILanguage(context) manager = ITranslationManager(context) if lang_support.get_language() == '': lang_support.set_language( context.portal_languages.getPreferredLanguage()) canLang = lang_support.get_language() # if the user didn't select target languages, get all supported languages # from the language tool if not target_languages: portal_languages = getToolByName(context, 'portal_languages') target_languages = portal_languages.getSupportedLanguages() content_helper = IContentHelper(context) for lang in target_languages: if lang == canLang: continue res = list() if not manager.get_translation(lang): if not translation_exists: # need to make lang a string. It can be unicode so checkid will # freak out and lead to an infinite recursion manager.add_translation(str(lang)) res.append("Added Translation for %s" % lang) # For a new translation, make sure the title is copied as well attrs = content_helper.check_for_title_attr(attrs) else: warnings.append( u'Translation in language %s does not exist, ' 'skipping' % lang) continue else: if not translation_exists: warnings.append( u'Translation for language %s already ' 'exists, skipping' % lang) continue res.append(u"Found translation for %s " % lang) trans = manager.get_translation(lang) content_results = content_helper.copy_attributes(trans, attrs) res.extend(content_results['res']) warnings.extend(content_results['warnings']) info.append(u"\n".join(res)) return (info, warnings, errors)
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: languages.append(SimpleVocabulary.createTerm(lang, lang, \ language_infos[lang].get('name', lang))) return SimpleVocabulary(languages)
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 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 __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() # If there is any session tg lets use the session tg sdm = self.context.session_data_manager session = sdm.getSessionData(create=True) if 'tg' in session.keys(): self.group = TranslationManager(session['tg']) else: self.group = ITranslationManager(self.context)
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: translation = manager.get_restricted_translation(lang) if translation is not None: term = SimpleVocabulary.createTerm(lang, lang, translation.absolute_url()) languages.append(term) return SimpleVocabulary(languages)
def test_duplicate_translations_are_discarded_when_linking(self): folder_uhoh = create(Builder('folder').titled('uhoh')) self.items = self.items[:2] self.items.append({ '_path': '/uhoh', '_canonicalTranslation': False, '_translationOf': '/de', 'language': 'en', }) items = self._run_transmogrifier() self.assertEqual(3, len(items)) uhoh_manager = ITranslationManager(folder_uhoh) manager = ITranslationManager(self.folder_en) uhoh_manager.update() manager.update() self.assertEqual('en', ILanguage(folder_uhoh).get_language()) self.assertEqual(1, len(uhoh_manager.get_translated_languages())) languages = manager.get_translated_languages() self.assertEqual(2, len(languages)) self.assertIn('de', languages) self.assertIn('en', languages)
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 back_references(source_object, attribute_name): """ Return back references from source object on specified attribute_name """ language_tool = getToolByName(source_object, 'portal_languages') default_language = language_tool.getDefaultLanguage() default_rels = [] # if this object is translatable, we should get the back relationship from the # default language of this object if ITranslatable.providedBy(source_object): trans_manager = ITranslationManager(aq_inner(source_object)) default_lang_obj = trans_manager.get_translation(default_language) if default_lang_obj: default_rels = _back_references(default_lang_obj, attribute_name, source_object) return list(set(default_rels + _back_references(source_object, attribute_name)))
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 at_back_references(source_object, relationship): language_tool = getToolByName(source_object, 'portal_languages') default_language = language_tool.getDefaultLanguage() # if this object is translatable, we should get the back relationship from the # default language of this object default_rels = [] if ITranslatable.providedBy(source_object): trans_manager = ITranslationManager(aq_inner(source_object)) default_lang_obj = trans_manager.get_translation(default_language) if default_lang_obj: default_rels = _at_back_references(default_lang_obj, relationship, source_object) return list(set(default_rels + _at_back_references(source_object, relationship)))
def linkTranslations(self): """ Links the translations of the default language Folders """ doneSomething = False canonical = ITranslationManager(self.folders[self.defaultLanguage]) for language in self.languages: if ((language != self.defaultLanguage) and (not canonical.has_translation(language))): canonical.register_translation(language, self.folders[language]) doneSomething = True if doneSomething: LOG.info("Translations linked.") return doneSomething
def translated_languages(context): language_tool = getToolByName(context, 'portal_languages') language_infos = language_tool.getAvailableLanguages() 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: 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 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: if not (filter_default and lang == default_language): languages.append(SimpleVocabulary.createTerm(lang, lang, \ language_infos[lang].get('name', lang))) return SimpleVocabulary(languages)
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 objectTranslated(ob, event): createdEvent(ob, event) if ITranslatable.providedBy(ob): if ob.language == "en" and ob.portal_type != "Folder": if not hasattr(ob, 'slideshow'): if ITranslationManager(ob).has_translation('nl'): original_ob = ITranslationManager(ob).get_translation('nl') if hasattr(original_ob, 'slideshow'): slideshow = original_ob['slideshow'] ITranslationManager(slideshow).add_translation('en') slideshow_trans = ITranslationManager(slideshow).get_translation('en') slideshow_trans.title = slideshow.title slideshow_trans.portal_workflow.doActionFor(slideshow_trans, "publish", comment="Slideshow published") for sitem in slideshow: if slideshow[sitem].portal_type == "Image": ITranslationManager(slideshow[sitem]).add_translation('en') trans = ITranslationManager(slideshow[sitem]).get_translation('en') trans.image = slideshow[sitem].image addCropToTranslation(slideshow[sitem], trans) ob.reindexObject() ob.reindexObject(idxs=["hasMedia"]) ob.reindexObject(idxs=["leadMedia"]) else: ob.invokeFactory( type_name="Folder", id=u'slideshow', title='slideshow', ) folder = ob['slideshow'] ILanguage(folder).set_language(ob.language) try: folder.portal_workflow.doActionFor(folder, "publish", comment="Slideshow content automatically published") ob.reindexObject() except: pass # TODO - check if NL has slideshow return return
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 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 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 __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 getAudios(self): resultat = [] manager = ITranslationManager(self.context) translations = manager.get_translations() util = queryUtility(IContentLanguageAvailability) languages = util.getLanguages() for translation in translations: formula = translations[translation] for i in formula.items(): locucio = i[1] idioma = languages[locucio.title]['native'] resultat.append({ 'idioma': idioma, 'url': locucio.absolute_url, 'nom_formula': locucio.nom_formula, 'locucio': locucio.locucio }) return resultat
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 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 __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) field = self.request.form['field'].split('.')[-1] if hasattr(orig_object, field): question = getattr(orig_object, field, '') if hasattr(question, 'raw'): question = question.raw else: return _("Invalid field") return google_translate(question, settings.google_translation_key, lang_target, lang_source)
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 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 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