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.info(
'%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 test_post_to_folder_creates_document_translated(self):
response = requests.post(
f"{self.portal.absolute_url()}/de",
headers={"Accept": "application/json"},
auth=(SITE_OWNER_NAME, SITE_OWNER_PASSWORD),
json={
"@type": "Document",
"id": "mydocument",
"title": "My Document DE",
"translation_of": self.es_content.UID(),
"language": "de",
},
)
self.assertEqual(201, response.status_code)
transaction.commit()
manager = ITranslationManager(self.es_content)
self.assertTrue("de" in manager.get_translations())
self.assertEqual("My Document DE",
manager.get_translations()["de"].title)
self.assertEqual("Document", response.json().get("@type"))
self.assertEqual("mydocument", response.json().get("id"))
self.assertEqual("My Document DE", response.json().get("title"))
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.info(
'%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 test_content_is_linked(self):
items = self._run_transmogrifier()
self.assertEqual(4, len(items))
manager = ITranslationManager(self.folder_en)
self.assertEqual(self.folder_de, manager.get_translation('de'),
'English and German content should be linked.')
self.assertEqual(2, len(manager.get_translations()))
manager = ITranslationManager(self.file_de)
self.assertEqual(self.file_en, manager.get_translation('en'),
'English and German content should be linked.')
self.assertEqual(2, len(manager.get_translations()))
def test_content_is_linked(self):
items = self._run_transmogrifier()
self.assertEqual(4, len(items))
manager = ITranslationManager(self.folder_en)
self.assertEqual(self.folder_de, manager.get_translation('de'),
'English and German content should be linked.')
self.assertEqual(2, len(manager.get_translations()))
manager = ITranslationManager(self.file_de)
self.assertEqual(self.file_en, manager.get_translation('en'),
'English and German content should be linked.')
self.assertEqual(2, len(manager.get_translations()))
def reply(self):
# Disable CSRF protection
if "IDisableCSRFProtection" in dir(plone.protect.interfaces):
alsoProvides(self.request,
plone.protect.interfaces.IDisableCSRFProtection)
data = json_body(self.request)
manager = ITranslationManager(self.context)
language = data.get("language", None)
if language is None:
self.request.response.setStatus(400)
return dict(error=dict(
type="BadRequest",
message="You need to provide the language to unlink",
))
if language not in list(manager.get_translations()):
self.request.response.setStatus(400)
return dict(error=dict(
type="BadRequest",
message="This objects is not translated into {}".format(
language),
))
manager.remove_translation(language)
return self.reply_no_content()
def reply(self):
# Disable CSRF protection
if 'IDisableCSRFProtection' in dir(plone.protect.interfaces):
alsoProvides(self.request,
plone.protect.interfaces.IDisableCSRFProtection)
data = json_body(self.request)
manager = ITranslationManager(self.context)
language = data.get('language', None)
if language is None:
self.request.response.setStatus(400)
return dict(error=dict(
type='BadRequest',
message='You need to provide the language to unlink'))
if language not in manager.get_translations().keys():
self.request.response.setStatus(400)
return dict(
error=dict(type='BadRequest',
message='This objects is not translated into {}'.
format(language)))
manager.remove_translation(language)
self.request.response.setStatus(204)
return {}
def test_move_content_existing_translation_inside(self):
f_ca = createContentInContainer(self.portal['ca'],
'Folder',
title=u"Test folder")
a_ca = createContentInContainer(self.portal['ca']['test-folder'],
'Document',
title=u"Test document")
a_en = api.translate(a_ca, 'en')
translations = ITranslationManager(self.portal['en'][a_en.id])
self.assertEqual(
translations.get_translations(), {
'ca': self.portal['ca'][f_ca.id][a_ca.id],
'en': self.portal['en'][a_ca.id]
})
self.assertIn(a_en.id, self.portal['en'].objectIds())
self.assertEqual(a_en, self.portal['en'][a_en.id])
# Change the content language of the created folder to 'en'
multilingualMoveObject(f_ca, 'en')
self.assertIn(f_ca.id, self.portal['en'].objectIds())
self.assertEqual(f_ca, self.portal['en'][f_ca.id])
self.assertIn(a_ca.id, self.portal['en'][f_ca.id].objectIds())
self.assertEqual(a_ca, self.portal['en'][f_ca.id][a_ca.id])
adapter = ILanguage(self.portal['en'][f_ca.id])
self.assertEqual(adapter.get_language(), 'en')
adapter = ILanguage(self.portal['en'][f_ca.id][a_ca.id])
self.assertEqual(adapter.get_language(), 'en')
translations = ITranslationManager(self.portal['en'][f_ca.id][a_ca.id])
self.assertEqual(translations.get_translations(),
{'en': self.portal['en'][f_ca.id][a_ca.id]})
translations = ITranslationManager(self.portal['en'][a_en.id])
self.assertEqual(translations.get_translations(),
{'en': self.portal['en'][a_en.id]})
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 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 test_translation_linking_by_path(self):
response = requests.post(
"{}/@translations".format(self.en_content.absolute_url()),
headers={"Accept": "application/json"},
auth=(SITE_OWNER_NAME, SITE_OWNER_PASSWORD),
json={"id": "/es/test-document"},
)
self.assertEqual(201, response.status_code)
transaction.begin()
manager = ITranslationManager(self.en_content)
for language, translation in manager.get_translations():
if language == ILanguage(self.es_content).get_language():
self.assertEqual(translation, self.es_content)
def test_translation_unlinking_succeeds(self):
response = requests.delete(
"{}/@translations".format(self.en_content.absolute_url()),
headers={"Accept": "application/json"},
auth=(SITE_OWNER_NAME, SITE_OWNER_PASSWORD),
json={"language": "es"},
)
self.assertEqual(204, response.status_code)
transaction.begin()
manager = ITranslationManager(self.en_content)
self.assertNotIn(
ILanguage(self.es_content).get_language(), list(manager.get_translations())
)
def test_move_content_existing_translation_inside(self):
f_ca = createContentInContainer(
self.portal['ca'], 'Folder', title=u"Test folder")
a_ca = createContentInContainer(
self.portal['ca']['test-folder'],
'Document', title=u"Test document")
a_en = api.translate(a_ca, 'en')
translations = ITranslationManager(self.portal['en'][a_en.id])
self.assertEqual(translations.get_translations(),
{'ca': self.portal['ca'][f_ca.id][a_ca.id],
'en': self.portal['en'][a_ca.id]})
self.assertIn(a_en.id, self.portal['en'].objectIds())
self.assertEqual(a_en, self.portal['en'][a_en.id])
# Change the content language of the created folder to 'en'
multilingualMoveObject(f_ca, 'en')
self.assertIn(f_ca.id, self.portal['en'].objectIds())
self.assertEqual(f_ca, self.portal['en'][f_ca.id])
self.assertIn(a_ca.id, self.portal['en'][f_ca.id].objectIds())
self.assertEqual(a_ca, self.portal['en'][f_ca.id][a_ca.id])
adapter = ILanguage(self.portal['en'][f_ca.id])
self.assertEqual(adapter.get_language(), 'en')
adapter = ILanguage(self.portal['en'][f_ca.id][a_ca.id])
self.assertEqual(adapter.get_language(), 'en')
translations = ITranslationManager(self.portal['en'][f_ca.id][a_ca.id])
self.assertEqual(translations.get_translations(),
{'en': self.portal['en'][f_ca.id][a_ca.id]})
translations = ITranslationManager(self.portal['en'][a_en.id])
self.assertEqual(translations.get_translations(),
{'en': self.portal['en'][a_en.id]})
def test_translation_linking_succeeds(self):
response = requests.post(
'{}/@translations'.format(self.en_content.absolute_url()),
headers={'Accept': 'application/json'},
auth=(SITE_OWNER_NAME, SITE_OWNER_PASSWORD),
json={
"id": self.es_content.absolute_url(),
},
)
self.assertEqual(201, response.status_code)
transaction.begin()
manager = ITranslationManager(self.en_content)
for language, translation in manager.get_translations():
if language == ILanguage(self.es_content).get_language():
self.assertEqual(translation, self.es_content)
def reply(self):
manager = ITranslationManager(self.context)
info = {
'@id': self.context.absolute_url(),
'language': ILanguage(self.context).get_language(),
'translations': []
}
for language, translation in manager.get_translations().items():
if language != ILanguage(self.context).get_language():
info['translations'].append({
'@id': translation.absolute_url(),
'language': language,
})
return info
def __call__(self, expand=False):
result = {
"translations": {
"@id": "{}/@translations".format(self.context.absolute_url())
}
}
if not expand:
return result
translations = []
manager = ITranslationManager(self.context)
for language, translation in manager.get_translations().items():
if language != ILanguage(self.context).get_language():
translations.append(
{"@id": translation.absolute_url(), "language": language}
)
result["translations"]["items"] = translations
return result
def __call__(self, expand=False):
result = {
'translations': {
'@id': '{}/@translations'.format(self.context.absolute_url()),
},
}
if not expand:
return result
translations = []
manager = ITranslationManager(self.context)
for language, translation in manager.get_translations().items():
if language != ILanguage(self.context).get_language():
translations.append({
'@id': translation.absolute_url(),
'language': language,
})
result['translations']['items'] = translations
return result
def reply(self):
# Disable CSRF protection
if "IDisableCSRFProtection" in dir(plone.protect.interfaces):
alsoProvides(self.request,
plone.protect.interfaces.IDisableCSRFProtection)
data = json_body(self.request)
manager = ITranslationManager(self.context)
language = data.get("language", None)
if language is None:
self.request.response.setStatus(400)
return dict(error=dict(
type="BadRequest",
message="You need to provide the language to unlink",
))
elif language not in list(manager.get_translations()):
self.request.response.setStatus(400)
return dict(error=dict(
type="BadRequest",
message=f"This objects is not translated into {language}",
))
elif self.context.portal_type == "LRF":
self.request.response.setStatus(400)
return dict(error=dict(
type="BadRequest",
message="Language Root Folders cannot be unlinked",
))
manager.remove_translation(language)
# We want to leave a log in the transaction that the unlink has been executed
ts = transaction.get()
ts.note(
f'Unlinked translation for {language} in {"/".join(self.context.getPhysicalPath())} ({self.context.language})'
)
return self.reply_no_content()
class BabelUtils(BrowserView):
def __init__(self, context, request):
super(BabelUtils, self).__init__(context, request)
portal_state = getMultiAdapter((context, request),
name="plone_portal_state")
self.portal_url = portal_state.portal_url()
# If there is any translation_info lets use it
try:
self.group = TranslationManager(request.translation_info['tg'])
except AttributeError:
self.group = ITranslationManager(self.context)
def getGroup(self):
return self.group
def getTranslatedLanguages(self):
return self.group.get_translated_languages()
def getPortal(self):
portal_url = getToolByName(self.context, 'portal_url')
return portal_url
def objToTranslate(self):
return self.context
def gtenabled(self):
registry = getUtility(IRegistry)
settings = registry.forInterface(IMultiLanguageExtraOptionsSchema,
prefix="plone")
key = settings.google_translation_key
return key is not None and len(key.strip()) > 0
def languages(self):
""" Deprecated """
context = aq_inner(self.context)
ls = LanguageSelector(context, self.request, None, None)
ls.update()
results = ls.languages()
supported_langs = [v['code'] for v in results]
missing = set([str(c) for c in supported_langs])
lsv = LanguageSelectorViewlet(context, self.request, None, None)
translations = lsv._translations(missing)
# We want to see the babel_view
append_path = ('', 'babel_view',)
non_viewable = set()
for data in results:
code = str(data['code'])
data['translated'] = code in translations.keys()
appendtourl = '/'.join(append_path)
if data['translated']:
trans, direct, has_view_permission = translations[code]
if not has_view_permission:
# shortcut if the user cannot see the item
non_viewable.add((data['code']))
continue
data['url'] = trans.absolute_url() + appendtourl
else:
non_viewable.add((data['code']))
# filter out non-viewable items
results = [r for r in results if r['code'] not in non_viewable]
return results
def translated_languages(self):
context = aq_inner(self.context)
tool = getToolByName(context, 'portal_languages', None)
checkPermission = getSecurityManager().checkPermission
translations = self.group.get_translations()
translated_info =\
[dict(code=key,
info=tool.getAvailableLanguageInformation()[key],
obj=translations[key]) for key in translations]
default_language = tool.getDefaultLanguage()
translated_shown = []
for lang_info in translated_info:
# Mark the default language as the first translation shown
if lang_info['code'] == default_language:
lang_info['isDefault'] = True
else:
lang_info['isDefault'] = False
# Remove the translation of the content currently being
# translated In case it's temporal we show as language is not
# already set on AT
portal_factory = getToolByName(
self.context,
'portal_factory',
None
)
context_language = ILanguage(context).get_language()
if (portal_factory is None or
not portal_factory.isTemporary(self.context)) \
and lang_info['code'] == context_language:
continue
# Remove the translation in case the translator user does not
# have permissions over it
has_view_permission =\
bool(checkPermission('View', lang_info['obj']))
if not has_view_permission:
continue
translated_shown.append(lang_info)
return translated_shown
def current_language_name(self):
""" Get the current language native name """
adapted = ILanguage(self.context)
lang_code = adapted.get_language()
util = getUtility(IContentLanguageAvailability)
data = util.getLanguages(True)
lang_info = data.get(lang_code)
return lang_info.get('native', None) or lang_info.get('name')
def max_nr_of_buttons(self):
registry = getUtility(IRegistry)
settings = registry.forInterface(IMultiLanguageExtraOptionsSchema,
prefix="plone")
return settings.buttons_babel_view_up_to_nr_translations
def already_translated(self):
tm = ITranslationManager(self.context)
return tm.get_translations()
