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 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 _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 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 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 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 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 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 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 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 __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 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
