def resetDefaultPage(self):
"""Maintain the default page of the site on the language it was defined
"""
previousDefaultPage = getattr(self.context, self.previousDefaultPageId)
languageWrapped = ILanguage(previousDefaultPage, None)
# If the previous default page cannot be adapted, do nothing.
# This might be the case if it is a Python Script or other non-portal
# content
if languageWrapped is None:
return False
language = languageWrapped.get_language()
pageId = self.previousDefaultPageId
# test language neutral
if language == '':
language = self.defaultLanguage
target = self.folders[language]
objects = self.context.manage_cutObjects(pageId)
try:
target.manage_pasteObjects(objects)
except ValueError, exc:
# This portal_type may not be allowed. This should not be
# fatal, so we only log a warning.
logger.warn((u"Could not move default page '{0:s}' j"
u"to folder '{1:s}': {2:s}").format(
pageId, target.getId(), exc))
return False
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 get_language(self):
info = mirror_info(self.context)
return (
ILanguage(info.mirror)
if info.mirror
else ILanguage(info.master)
if info.master
else super()
).get_language()
def test_language_is_set(self):
items = self._run_transmogrifier()
self.assertEqual(4, len(items))
self.assertEqual('de', ILanguage(self.folder_de).get_language())
self.assertEqual('en', ILanguage(self.folder_en).get_language())
self.assertEqual('de', ILanguage(self.file_de).get_language())
self.assertEqual('en', ILanguage(self.file_en).get_language())
def test_monkey_folderish(self):
self.browser.addHeader('Authorization', auth_header)
folder = makeContent(self.portal, 'Folder', id='folder')
ILanguage(folder).set_language('ca')
transaction.commit()
self.browser.open('{0:s}/createObject?type_name=Document'.format(
folder.absolute_url()))
self.browser.getControl(name="title").value = "subfolder"
self.browser.getControl(name="form.button.save").click()
self.assertEqual(ILanguage(folder['subfolder']).get_language(), 'ca')
def test_content_moved_from_LRF_into_LRI(self):
doc_id = self.lrf_de.invokeFactory('Document', 'lri-document')
doc = self.lrf_de[doc_id]
self.assertEqual(ILanguage(doc).get_language(), 'de')
# now we move the doc into 'de' folder and the language should be
# automatically set to 'de'.
self.lri_neutral.manage_pasteObjects(
self.lrf_de.manage_copyObjects(ids=[doc_id]))
doc = self.lri_neutral[doc_id]
self.assertEqual(ILanguage(doc).get_language(), '')
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):
plone_utils = getToolByName(self.context, "plone_utils")
if self.context.__class__ == LanguageRootFolder:
self.request.response.redirect(self.context.absolute_url())
return
if not IPloneSiteRoot.providedBy(aq_parent(aq_inner(self.context))):
plone_utils.addPortalMessage(
_(u"folder_to_lrf_not_next_to_root",
default=u"Only folders just below the root "
u"can be transformed")
)
self.request.response.redirect(self.context.absolute_url())
return
portal_languages = getToolByName(self.context, "portal_languages")
available_languages = portal_languages.getAvailableLanguages()
if self.context.id not in available_languages.keys():
plone_utils.addPortalMessage(
_(u"folder_to_lrf_id_not_language",
default=u"Folder's id is not a valid language code")
)
self.request.response.redirect(self.context.absolute_url())
return
# Do the transform
self.context.__class__ = LanguageRootFolder
self.context._p_changed = aq_parent(self.context).p_changed = True
self.context.portal_type = 'LRF'
# Update content language
portal_catalog = getToolByName(self.context, "portal_catalog")
search_results = portal_catalog.unrestrictedSearchResults(
path='/'.join(self.context.getPhysicalPath()))
for brain in search_results:
ob = brain._unrestrictedGetObject()
language_aware = ILanguage(ob, None)
if language_aware is not None:
language_aware.set_language(self.context.id)
ob.reindexObject(idxs=['Language', 'TranslationGroup'])
plone_utils.addPortalMessage(
_(u"folder_to_lrf_success",
default=u"Folder has been successfully transformed to "
u"a language root folder")
)
self.request.response.redirect(self.context.absolute_url())
def __call__(self):
plone_utils = getToolByName(self.context, "plone_utils")
if self.context.__class__ == LanguageRootFolder:
self.request.response.redirect(self.context.absolute_url())
return
if not IPloneSiteRoot.providedBy(aq_parent(aq_inner(self.context))):
plone_utils.addPortalMessage(
_(u"folder_to_lrf_not_next_to_root",
default=u"Only folders just below the root "
u"can be transformed")
)
self.request.response.redirect(self.context.absolute_url())
return
portal_languages = getToolByName(self.context, "portal_languages")
available_languages = portal_languages.getAvailableLanguages()
if self.context.id not in available_languages.keys():
plone_utils.addPortalMessage(
_(u"folder_to_lrf_id_not_language",
default=u"Folder's id is not a valid language code")
)
self.request.response.redirect(self.context.absolute_url())
return
# Do the transform
self.context.__class__ = LanguageRootFolder
self.context._p_changed = aq_parent(self.context).p_changed = True
self.context.portal_type = 'LRF'
# Update content language
portal_catalog = getToolByName(self.context, "portal_catalog")
search_results = portal_catalog.unrestrictedSearchResults(
path='/'.join(self.context.getPhysicalPath()))
for brain in search_results:
ob = brain._unrestrictedGetObject()
language_aware = ILanguage(ob, None)
if language_aware is not None:
language_aware.set_language(self.context.id)
ob.reindexObject(idxs=['Language', 'TranslationGroup'])
plone_utils.addPortalMessage(
_(u"folder_to_lrf_success",
default=u"Folder has been successfully transformed to "
u"a language root folder")
)
self.request.response.redirect(self.context.absolute_url())
def test_duplicate_translations_are_discarded_when_linking(self):
folder_uhoh = create(Builder('folder').titled(u'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 update(self):
""" It's only for AT on factory so we check """
if self.context.portal_factory.isTemporary(self.context):
if ITranslatable.providedBy(self.context):
self.lang = ILanguage(self.context).get_language()
else:
self.lang = 'NaN'
def set_recursive_language(ob, language):
"""Set the language for this object and its children in a recursive
manner
"""
if is_language_independent(ob):
ILanguage(ob).set_language(None)
elif ILanguage(ob).get_language() != language:
ILanguage(ob).set_language(language)
ITranslationManager(ob).update()
reindex_object(ob)
for child in (IFolderish.providedBy(ob) and ob.items() or ()):
if ITranslatable.providedBy(child):
set_recursive_language(child, language)
def test_created_event(self):
"""When an object is created in a folder it takes its language from the
folder itself
"""
a_ca = createContentInContainer(
self.portal['ca'], 'Document', title=u"Test document")
self.assertEqual(ILanguage(a_ca).get_language(), 'ca')
def getMenuItems(self, context, request):
menu = super(TranslateMenu, self).getMenuItems(context, request)
url = context.absolute_url()
is_neutral_content = (
ILanguage(context).get_language() == LANGUAGE_INDEPENDENT or
is_language_independent(context)
)
if not is_neutral_content and not INavigationRoot.providedBy(context):
if ITranslatable.providedBy(context) and getSecurityManager().checkPermission('Manage portal', context):
menu.append({
"title": _(
u"title_mirror_content",
default=u"Mirror this object to other languages"
),
"description": _(
u"description_mirror_content",
default=u""
),
"action": url + "/mirror_content",
"selected": False,
"icon": None,
"extra": {
"id": "_mirror_content",
"separator": None,
"class": ""
},
"submenu": None,
})
return menu
def update(self):
""" Update the adapted item.
If unregistered, register a Translation-Grouup (TG) for it and exit.
Check that there aren't two translations on the same language
This is to be used for changing the contexts language.
If there is already an item in the same language,
Remove the other items TG information and make the current adapted
context the active language for the current TG.
"""
language = ILanguage(self.context).get_language()
brains = self.pcatalog.unrestrictedSearchResults(
TranslationGroup=self.tg,
Language=language,
)
if len(brains) == 0:
# There is no translation within current TG for this language.
self.register_translation(language, self.context)
return
# In case the language is already within the translated languages we are
# going to orphan the old translation.
brain = brains[0]
content_id = self.get_id(self.context)
if brain.UID == content_id:
return
# It is a different object -> remove the old one
# We get the old uuid
old_object = brain.getObject()
IMutableTG(old_object).set(NOTG)
old_object.reindexObject(idxs=("TranslationGroup", ))
notify(TranslationUpdatedEvent(self.context, old_object, language))
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)
id_ = data.get("id", None)
if id_ is None:
self.request.response.setStatus(400)
return dict(error=dict(type="BadRequest",
message="Missing content id to link to"))
target = self.get_object(id_)
if target is None:
self.request.response.setStatus(400)
return dict(error=dict(type="BadRequest",
message="Content does not exist"))
target_language = ILanguage(target).get_language()
manager = ITranslationManager(self.context)
current_translation = manager.get_translation(target_language)
if current_translation is not None:
self.request.response.setStatus(400)
return dict(error=dict(
type="BadRequest",
message="Already translated into language {}".format(
target_language),
))
manager.register_translation(target_language, target)
self.request.response.setStatus(201)
self.request.response.setHeader("Location",
self.context.absolute_url())
return {}
def default_base_path(context=None):
portal = api.portal.get()
# can this actually happen?
if not context:
request = getRequest()
context = request.PARENTS[0]
log.info(context)
try:
language = ILanguage(context).get_language()
except TypeError:
# FIX ME!
# deal with <TypeSchemaContext at Collection>
# when editing content type ttw
# by checking if it is dexteritycontent
# we do a similar thing in mdb_theme
language = 'de'
pass
# this should return the portal if plone.app.multilingual is not installed
language_root = portal.get(language, portal)
root_path = '/'.join(language_root.getPhysicalPath())
return root_path
def setUp(self):
self.portal = self.layer['portal']
self.request = self.layer['request']
alsoProvides(self.layer['request'], IPloneAppMultilingualInstalled)
self.ltool = getToolByName(self.portal, 'portal_languages')
self.ltool.addSupportedLanguage('de')
self.ltool.addSupportedLanguage('en')
setRoles(self.portal, TEST_USER_ID, ['Manager'])
login(self.portal, TEST_USER_NAME)
self.lrf_de = makeContent(self.portal, 'LRF', id='de')
ILanguage(self.lrf_de).set_language('de')
self.lrf_en = makeContent(self.portal, 'LRF', id='en')
ILanguage(self.lrf_en).set_language('en')
self.lri_neutral = makeContent(self.portal, 'LRF', id='neutral')
def test_created_event_on_portal(self):
"""When an object is created on portal it should be language
independent
"""
a_ca = createContentInContainer(
self.portal, 'Document', title=u"Test document")
self.assertEqual(ILanguage(a_ca).get_language(), '')
def test_initial_language_set(self):
# Create
a_ca = createContentInContainer(self.portal['ca'],
'Document',
title=u"Test document")
# Check that the content has language
self.assertEqual(ILanguage(a_ca).get_language(), 'ca')
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)
id_ = data.get("id", None)
if id_ is None:
self.request.response.setStatus(400)
return dict(error=dict(type="BadRequest",
message="Missing content id to link to"))
target = self.get_object(id_)
if target is None:
self.request.response.setStatus(400)
return dict(error=dict(type="BadRequest",
message="Content does not exist"))
elif target.portal_type == "LRF":
self.request.response.setStatus(400)
return dict(error=dict(
type="BadRequest",
message=
"Language Root Folders can only be linked between each other",
))
target_language = ILanguage(target).get_language()
manager = ITranslationManager(self.context)
current_translation = manager.get_translation(target_language)
target_manager = ITranslationManager(target)
target_translation = target_manager.get_translation(
self.context.language)
if current_translation is not None:
self.request.response.setStatus(400)
return dict(error=dict(
type="BadRequest",
message="Source already translated into language {}".format(
target_language),
))
if target_translation is not None:
self.request.response.setStatus(400)
return dict(error=dict(
type="BadRequest",
message="Target already translated into language {}".format(
target_language),
))
manager.register_translation(target_language, target)
# We want to leave a log in the transaction that the link has been executed
ts = transaction.get()
ts.note(
f'Linked translation {"/".join(self.context.getPhysicalPath())} ({self.context.language}) -> {"/".join(target.getPhysicalPath())} ({target_language})'
)
self.request.response.setStatus(201)
self.request.response.setHeader("Location",
self.context.absolute_url())
return {}
def test_copied_event(self):
a_ca = createContentInContainer(self.portal['ca'],
'Document',
title=u"Test document")
id_ = self.portal['ca'].manage_copyObjects(a_ca.id)
self.portal['en'].manage_pasteObjects(id_)
a_ca_copied = self.portal['en'][a_ca.id]
self.assertEqual(ILanguage(a_ca_copied).get_language(), 'en')
def test_correct_translation_information(self):
tinfo = getMultiAdapter((self.en_content, self.request),
name="GET_application_json_@translations")
info = tinfo.reply()
tinfo_es = info["items"][0]
self.assertEqual(self.es_content.absolute_url(), tinfo_es["@id"])
self.assertEqual(
ILanguage(self.es_content).get_language(), tinfo_es["language"])
def sendSignOffNotification(person):
isEmail = validation.validatorFor('isEmail')
timeSlot = person.aq_parent
day = timeSlot.aq_parent
signupSheet = day.aq_parent
lang = ILanguage(signupSheet).get_language()
if len(lang) == 0:
lang = 'de'
contactInfo = signupSheet.contactInfo
extraInfoStr = person.getExtraInfoAsString()
fromEmail = signupSheet.contactInfo
# mail to person who signed up
if isEmail(person.email) != 1:
return
url = signupSheet.absolute_url()
toEmail = person.email
subject = signupSheet.emailCancelSubject
if subject is None or len(subject) == 0:
subject = signupSheet.Title() + ' - ' \
+ translate(_(u'Cancellation Notification'),
target_language=lang)
else:
subject = replaceCustomMailPlaceholders(
subject, person.Title(), signupSheet.Title(), url,
timeSlot.getLabel(), extraInfoStr)
content = signupSheet.emailCancelContent
if content is not None and len(content) > 0:
message = replaceCustomMailPlaceholders(
content, person.Title(), signupSheet.Title(), url,
timeSlot.getLabel(), extraInfoStr)
else:
# default message if no content has been specified
message = translate(_(u'Hello'), target_language=lang) + ' ' + person.Title() + ',\n\n'
message += translate(_(u'Following slot has been cancelled:'),
target_language=lang) + '\n'
message += timeSlot.getLabel() + '\n\n'
if len(extraInfoStr) > 0:
message += translate(_(u'Additional information'),
target_language=lang) + '\n'
message += extraInfoStr + '\n\n'
if len(contactInfo) > 0:
message += translate(_('If you have any questions please contact:'),
target_language=lang) + ' ' + contactInfo + '\n\n'
message += url + '\n\n'
api.portal.send_email(recipient=toEmail, sender=fromEmail,
subject=subject, body=message)
def testContentObject(self):
self.layer['portal'].invokeFactory('Document', 'doc')
doc = self.layer['portal'].doc
ILanguage(doc).set_language('nl')
self.failUnlessEqual(doc.Language(), 'nl')
docpath = '/'.join(doc.getPhysicalPath())
response = self.publish(docpath,
self.basic_auth,
env={'PATH_INFO': docpath})
self.checkLanguage(response, "nl")
def testContentObject(self):
self.layer["portal"].invokeFactory("Document", "doc")
doc = self.layer["portal"].doc
ILanguage(doc).set_language("nl")
self.assertEqual(doc.Language(), "nl")
docpath = "/".join(doc.getPhysicalPath())
response = self.publish(docpath,
self.basic_auth,
env={"PATH_INFO": docpath})
self.checkLanguage(response, "nl")
def add(self, object):
super(MultilingualAddForm, self).add(object)
language = ILanguage(object).get_language()
# extract UID from URL to get source object
# probably there is a better way to do that!?
parts = self.request.getURL().split('++')
if not parts:
return
source = uuidToObject(parts[-1])
notify(ObjectTranslatedEvent(source, object, language))
def test_moved_to_assets_folder(self):
"""When an object is moved from within one Language Root Folder into
the Language Independent Folder (named 'Assets') it becomes language
independent, and it should be visible from the assets folder accessed
from within other Language Root Folders
"""
a_ca = createContentInContainer(self.portal['ca'],
'Document',
title=u"Test document")
# Test a paste into a subfolder to be ultra cautious
ca_assets_subfolder = createContentInContainer(
self.portal['ca']['assets'], 'Folder', title=u"A Folder")
subfolder_name = ca_assets_subfolder.id
id_ = self.portal['ca'].manage_cutObjects(a_ca.id)
ca_assets_subfolder.manage_pasteObjects(id_)
# Get both assets folders afresh
ca_assets_subfolder = self.portal['ca']['assets'][subfolder_name]
en_assets_subfolder = self.portal['en']['assets'][subfolder_name]
# Check it is in both folder listings
self.assertTrue(a_ca.id in ca_assets_subfolder)
self.assertTrue(a_ca.id in en_assets_subfolder)
# Check it is language independent
copy_in_en = en_assets_subfolder[a_ca.id]
self.assertEqual(ILanguage(copy_in_en).get_language(), '')
copy_in_ca = ca_assets_subfolder[a_ca.id]
self.assertEqual(ILanguage(copy_in_ca).get_language(), '')
# Check it is returned in catalog search
catalog = getToolByName(self.portal, 'portal_catalog')
ca_subfolder_path = '/'.join(ca_assets_subfolder.getPhysicalPath())
ca_folder_contents = [r.id for r in catalog(path=ca_subfolder_path)]
self.assertTrue(a_ca.id in ca_folder_contents)
en_subfolder_path = '/'.join(en_assets_subfolder.getPhysicalPath())
en_folder_contents = [r.id for r in catalog(path=en_subfolder_path)]
self.assertTrue(a_ca.id in en_folder_contents)
def get_language(self):
language = self.context.Language()
portal_factory = getToolByName(self, 'portal_factory', None)
if portal_factory is not None and portal_factory.isTemporary(self):
navroot = getNavigationRootObject(self.context, getSite())
if navroot != self.context:
language = ILanguage(navroot).get_language()
if not language:
language = LANGUAGE_INDEPENDENT
return 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 test_copied_event(self):
"""When an object is copied from within one Language Root Folder into
a different Language Root Folder it changes its language to that of the
folder it is copied into
"""
a_ca = createContentInContainer(
self.portal['ca'], 'Document', title=u"Test document")
id_ = self.portal['ca'].manage_copyObjects(a_ca.id)
self.portal['en'].manage_pasteObjects(id_)
a_ca_copied = self.portal['en'][a_ca.id]
self.assertEqual(ILanguage(a_ca_copied).get_language(), 'en')
def test_move_content_proper_language_folder(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")
# Change the content language of the created folder to 'es'
multilingualMoveObject(f_ca, 'es')
self.assertIn(f_ca.id, self.portal['es'].objectIds())
self.assertEqual(f_ca, self.portal['es'][f_ca.id])
self.assertIn(a_ca.id, self.portal['es'][f_ca.id].objectIds())
self.assertEqual(a_ca, self.portal['es'][f_ca.id][a_ca.id])
adapter = ILanguage(self.portal['es'][f_ca.id])
self.assertEqual(adapter.get_language(), 'es')
adapter = ILanguage(self.portal['es'][f_ca.id][a_ca.id])
self.assertEqual(adapter.get_language(), 'es')
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]})
