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 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.
LOG.warn("Could not move default page '%s' to folder '%s': %s"
% (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 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 traverse(self, name, ignored):
# Populate translation info
self.info['target_language'] = ILanguage(self.context).get_language()
catalog = getToolByName(self.context, 'portal_catalog')
# Search source object using unrestricted API,
# because user may be anonymous during traverse.
brains = catalog.unrestrictedSearchResults(UID=name)
if len(brains) != 1:
raise TraversalError(self.context, name)
source = brains[0]._unrestrictedGetObject()
self.info['source_language'] = ILanguage(source).get_language()
self.info['portal_type'] = source.portal_type
self.info['tg'] = ITG(source)
# If source has already been translated to this language, just redirect
for brain in catalog.unrestrictedSearchResults(
TranslationGroup=self.info['tg'],
Language=self.info['target_language']):
self.request.response.redirect(brain.getURL())
return u''
# XXX: register this adapter on dx container and a second one for AT
if not IDexterityContent.providedBy(source):
# we are not on DX content, assume AT
baseUrl = self.context.absolute_url()
url = '%s/@@add_at_translation?type=%s' % (baseUrl, name)
return self.request.response.redirect(url)
# set the self.context to the place where it should be stored
if not IFolderish.providedBy(self.context):
self.context = self.context.__parent__
# get the type information
ttool = getToolByName(self.context, 'portal_types')
ti = ttool.getTypeInfo(self.info['portal_type'])
if ti is None:
logger.error('No type information found for {0}'.format(
self.info['portal_type']))
raise TraversalError(self.context, name)
registry = getUtility(IRegistry)
settings = registry.forInterface(IMultiLanguageExtraOptionsSchema)
if not settings.redirect_babel_view:
add_view = None
else:
add_view = queryMultiAdapter((self.context, self.request, ti),
name='babel_view')
if add_view is None:
add_view = queryMultiAdapter((self.context, self.request, ti))
if add_view is not None:
raise TraversalError(self.context, name)
add_view.__name__ = ti.factory
return add_view.__of__(self.context)
def render(self):
from plone.app.multilingual.interfaces import ILanguage
context = aq_inner(self.context)
pc = api.portal.get_tool('portal_catalog')
results = pc.unrestrictedSearchResults(path='/'.join(context.getPhysicalPath()))
for brain in 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'])
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 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_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_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 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 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 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_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_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 update(self):
try:
tg = self.request.translation_info['tg']
except AttributeError:
return
self.available = True
if ITranslatable.providedBy(self.context):
self.lang = ILanguage(self.context).get_language()
else:
self.lang = 'NaN'
catalog = getToolByName(self.context, 'portal_catalog')
query = {'TranslationGroup': tg, 'Language': 'all'}
self.origin = catalog.searchResults(query)
def test_add_translation(self):
# Check that document does not exists
self.assertNotIn('test-document', self.portal['es'].objectIds())
# Create es translation
ITranslationManager(self.a_ca).add_translation('es')
# Check if it exists
self.assertIn('test-document', self.portal['es'].objectIds())
# Check language
language = ILanguage(self.portal['es']['test-document']).get_language()
self.assertEqual(language, 'es')
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 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:
languages.append(
SimpleVocabulary.createTerm(
lang, lang, translation.absolute_url()))
return SimpleVocabulary(languages)
def createdEvent(obj, event):
""" Subscriber to set language on the child folder
It can be a
- IObjectRemovedEvent - don't do anything
- IObjectMovedEvent
- IObjectAddedEvent
- IObjectCopiedEvent
"""
if IObjectRemovedEvent.providedBy(event):
return
# On ObjectCopiedEvent and ObjectMovedEvent aq_parent(event.object) is
# always equal to event.newParent.
parent = aq_parent(event.object)
# special parent handling
if not ITranslatable.providedBy(parent):
set_recursive_language(obj, LANGUAGE_INDEPENDENT)
return
# Normal use case
# We set the tg, linking
language = ILanguage(parent).get_language()
set_recursive_language(obj, language)
request = getattr(event.object, 'REQUEST', getRequest())
try:
ti = request.translation_info
except AttributeError:
return
# AT check
portal = getSite()
portal_factory = getToolByName(portal, 'portal_factory', None)
if (
not IDexterityContent.providedBy(obj)
and portal_factory is not None
and not portal_factory.isTemporary(obj)
):
return
IMutableTG(obj).set(ti['tg'])
modified(obj)
tm = ITranslationManager(obj)
old_obj = tm.get_translation(ti['source_language'])
ILanguageIndependentFieldsManager(old_obj).copy_fields(obj)
def add_translation(self, language):
""" see interfaces """
if not language and language != '':
raise KeyError('There is no target language')
# event
notify(ObjectWillBeTranslatedEvent(self.context, language))
# create the translated object
translation_factory = ITranslationFactory(self.context)
translated_object = translation_factory(language)
ILanguage(translated_object).set_language(language)
# reindex the translated object
translated_object.reindexObject()
# register the new translation
self.register_translation(language, translated_object)
# event
notify(ObjectTranslatedEvent(self.context,
translated_object, language))
return
def translated_languages(context):
language_tool = getToolByName(context, 'portal_languages')
language_infos = language_tool.getAvailableLanguages()
manager = ITranslationManager(context)
# take care to filter out translated contents
# wich do no have supported language information
translated_languages = [a
for a in manager.get_translated_languages()
if a in language_infos]
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 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 __iter__(self):
for item in self.previous:
pathkey = self.pathkey(*item.keys())[0]
# not enough info
if not pathkey:
yield item
continue
path = item[pathkey]
# Skip the Plone site object itself
if not path:
yield item
continue
obj = self.context.unrestrictedTraverse(path.encode().lstrip('/'),
None)
if not IDexterityContent.providedBy(obj):
# Path doesn't exist
# obj can not only be None, but also the value of an attribute,
# which is returned by traversal.
yield item
continue
# fetch lang and translation group
lang = item.get(self.langkey)
tg = item.get(self.tgkey)
# no translation
if not lang or not tg:
yield item
continue
# set language and translation group
ILanguage(obj).set_language(lang)
IMutableTG(obj).set(tg)
obj.reindexObject()
yield item
def update(self):
""" see interfaces"""
language = ILanguage(self.context).get_language()
# self.context.reindexObject(idxs=("Language", "TranslationGroup", ))
# In case language is already on the translated languages we are
# going to orphan the old translation
brains = self.pcatalog.unrestrictedSearchResults(
TranslationGroup=self.tg, Language=language)
if len(brains) == 0:
# There is not a translation with this tg on this language
self.register_translation(language, self.context)
else:
# We need to check if the language has changed
brain = brains[0]
content_id = self.get_id(self.context)
if brain.UID != content_id:
# 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=(
"Language", "TranslationGroup",
))
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 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_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 __call__(self):
""" Get the JSON information about based on a nodeId
"""
# We get the language we are looking for
lang = ''
tool = getToolByName(self.context, 'portal_languages', None)
if 'lang' in self.request:
lang = self.request['lang']
if lang == '':
lang = tool.getDefaultLanguage()
# We want all or just the missing translations elements
if 'all' in self.request:
get_all = (self.request['all'] == 'true')
else:
get_all = True
# Which is the root nodeId
folder_path = ''
if 'nodeId' in self.request:
# We get the used UUID
nodeId = (self.request['nodeId'])
if (nodeId != 'root'):
new_root = uuidToObject(nodeId)
if ILanguage(new_root).get_language() == lang:
folder_path = '/'.join(new_root.getPhysicalPath())
if folder_path == '':
# We get the root folder
root = getToolByName(self.context, 'portal_url')
root = root.getPortalObject()
folder_path = '/'.join(root.getPhysicalPath())
self.request.response.setHeader("Content-type",
"application/json; charset=utf-8")
pcatalog = getToolByName(self.context, 'portal_catalog')
query = {}
query['path'] = {'query': folder_path, 'depth': 1}
query['sort_on'] = "sortable_title"
query['sort_order'] = "ascending"
query['Language'] = lang
search_results = pcatalog.searchResults(query)
resultat = {
'id': 'root',
'name': folder_path,
'data': {},
'children': []
}
supported_languages = tool.getSupportedLanguages()
for sr in search_results:
# We want to know the translated and missing elements
translations = {}
if 'TranslationGroup' in sr:
# We look for the brain for each translation
brains = pcatalog.unrestrictedSearchResults(
TranslationGroup=sr['TranslationGroup'])
languages = {}
for brain in brains:
languages[brain.Language] = brain.UID
for lang in supported_languages:
if lang in languages.keys():
translated_obj = uuidToObject(languages[lang])
translations[lang] = {
'url': translated_obj.absolute_url(),
'title': translated_obj.getId(),
}
else:
url_to_create = sr.getURL() + \
"/@@create_translation?form.widgets.language"\
"=%s&form.buttons.create=1" % lang
translations[lang] = {
'url': url_to_create,
'title': _(u'Not translated'),
}
if get_all:
resultat['children'].append({
'id': sr['UID'],
'name': sr['Title'],
'data': translations,
'children': [],
})
else:
pass
return json.dumps(resultat)
def setUpLanguage(self, code, name):
"""Create the language folders on top of the site
"""
doneSomething = False
if code == 'id':
folderId = 'id-id'
else:
folderId = str(code)
folder = getattr(self.context, folderId, None)
wftool = getToolByName(self.context, 'portal_workflow')
if folder is None:
_createObjectByType(self.folder_type, self.context, folderId)
_createObjectByType(self.folder_type_language_independent,
self.context[folderId], 'media')
folder = self.context[folderId]
ILanguage(folder).set_language(code)
folder.setTitle(name)
ILanguage(folder['media']).set_language(code)
folder['media'].setTitle(u'Media')
# This assumes a direct 'publish' transition from the initial state
# We are going to check if its private and has publish action for
# the out of the box case otherwise don't do anything
state = wftool.getInfoFor(folder, 'review_state', None)
available_transitions = [
t['id'] for t in wftool.getTransitionsFor(folder)
]
if state != 'published' and 'publish' in available_transitions:
wftool.doActionFor(folder, 'publish')
state = wftool.getInfoFor(folder['media'], 'review_state', None)
available_transitions = [
t['id'] for t in wftool.getTransitionsFor(folder['media'])
]
if state != 'published' and 'publish' in available_transitions:
wftool.doActionFor(folder['media'], 'publish')
# Exclude folder from navigation (if applicable)
adapter = IExcludeFromNavigation(folder, None)
if adapter is not None:
adapter.exclude_from_nav = True
adapter = IExcludeFromNavigation(folder['media'], None)
if adapter is not None:
adapter.exclude_from_nav = True
# We've modified the object; reindex.
notify(modified(folder))
notify(modified(folder['media']))
doneSomething = True
logger.info(u"Added '%s' folder: %s" % (code, folderId))
self.folders[code] = folder
if not INavigationRoot.providedBy(folder):
alsoProvides(folder, INavigationRoot)
doneSomething = True
logger.info(u"INavigationRoot setup on folder '%s'" % code)
return doneSomething
def getMenuItems(self, context, request):
"""Return menu item entries in a TAL-friendly form.
"""
try:
lang_names = request.locale.displayNames.languages
except AttributeError:
lang_names = {}
menu = []
url = context.absolute_url()
lt = getToolByName(context, "portal_languages")
site_url = getSite().absolute_url()
showflags = lt.showFlags()
context_id = ITranslationManager(context).tg
registry = getUtility(IRegistry)
settings = registry.forInterface(IMultiLanguageExtraOptionsSchema)
edit_view = 'babel_edit' if settings.redirect_babel_view else 'edit'
# In case is neutral language show set language menu only
is_neutral_content = (ILanguage(context).get_language()
== LANGUAGE_INDEPENDENT
or is_language_independent(context))
shared_folder_url = site_url + '/folder_contents'
pc = getToolByName(getSite(), 'portal_catalog')
results = pc.unrestrictedSearchResults(
portal_type='LIF', Language=ILanguage(context).get_language())
for brain in results:
shared_folder_url = brain.getURL() + '/folder_contents'
if not is_neutral_content and not INavigationRoot.providedBy(context):
menu.append({
"title":
_(u"title_babel_edit", default=u"Edit with babel view"),
"description":
_(u"description_babel_edit",
default=u"Edit with the babel_edit"),
"action":
url + "/" + edit_view,
"selected":
False,
"icon":
None,
"extra": {
"id": "_edit_babel_edit",
"separator": None,
"class": "",
},
"submenu":
None,
})
contexts = [
context,
]
prt = aq_parent(context)
if isDefaultPage(prt, context):
contexts.append(prt)
for idx, context in enumerate(contexts):
url = context.absolute_url()
ulangs = untranslated_languages(context)
for lang in ulangs:
lang_name = lang_names.get(lang.value, lang.title)
lang_id = lang.value
icon = showflags and lt.getFlagForLanguageCode(lang_id)\
or None
item = {
"description":
_(u"description_translate_into",
default=u"Translate into ${lang_name}",
mapping={"lang_name": lang_name}),
"action":
"%s/@@create_translation?language=%s" % (url, lang_id),
"selected":
False,
"icon":
icon,
"width":
"14",
"height":
"11",
"extra": {
"id": "translate_into_%s" % lang_id,
"separator": None,
"class": "contentmenuflags"
},
"submenu":
None,
}
item['title'] = idx and _(
u'create_translation_folder',
default=u"Create ${lang_name} folder",
mapping={"lang_name": lang_name}) or _(
u'create_translation',
default=u"Create ${lang_name}",
mapping={"lang_name": lang_name})
menu.append(item)
langs = translated_languages(context)
urls = translated_urls(context)
for lang in langs:
if lang.value not in urls.by_token:
# omit if translation is not permitted to access.
continue
lang_name = lang_names.get(lang.value, lang.title)
lang_id = lang.value
icon = showflags and lt.getFlagForLanguageCode(lang_id)\
or None
item = {
"description":
_(u"description_babeledit_menu",
default=u"Babel edit ${lang_name}",
mapping={"lang_name": lang_name}),
"action":
(urls.getTerm(lang_id).title + "/" + edit_view),
"selected":
False,
"icon":
icon,
"width":
"14",
"height":
"11",
"extra": {
"id": "babel_edit_%s" % lang_id,
"separator": None,
"class": "contentmenuflags"
},
"submenu":
None,
}
item['title'] = idx and _(
u'edit_translation_folder',
default=u"Edit ${lang_name} folder",
mapping={"lang_name": lang_name}) or _(
u'edit_translation',
default=u"Edit ${lang_name}",
mapping={"lang_name": lang_name})
menu.append(item)
item = {
"description":
_(u"description_add_translations",
default=u"Add existing content as translation"),
"action":
url + "/add_translations",
"selected":
False,
"icon":
None,
"extra": {
"id": "_add_translations",
"separator": langs and "actionSeparator" or None,
"class": ""
},
"submenu":
None,
}
item['title'] = idx and _(
u"title_add_translations_folder",
default=u"Add translations for folder...") or _(
u"title_add_translations",
default=u"Add translations...")
menu.append(item)
item = {
"title":
_(u"title_remove_translations",
default=u"Remove translations..."),
"description":
_(u"description_remove_translations",
default=u"Delete translations or remove the relations"),
"action":
url + "/remove_translations",
"selected":
False,
"icon":
None,
"extra": {
"id": "_remove_translations",
"separator": langs and "actionSeparator" or None,
"class": ""
},
"submenu":
None,
}
menu.append(item)
elif is_neutral_content:
menu.append({
"title":
_(u"language_folder", default=u"Return to language folder"),
"description":
_(u"description_language_folder",
default=u"Go to the user's browser preferred language "
u"related folder"),
"action":
site_url + '/' + lt.getPreferredLanguage(),
"selected":
False,
"icon":
None,
"extra": {
"id": "_shared_folder",
"separator": None,
"class": ""
},
"submenu":
None,
})
if not is_neutral_content:
menu.append({
"title":
_(u"universal_link", default=u"Universal Link"),
"description":
_(u"description_universal_link",
default=u"Universal Language content link"),
"action":
"%s/@@multilingual-universal-link/%s" % (site_url, context_id),
"selected":
False,
"icon":
None,
"extra": {
"id": "_universal_link",
"separator": None,
"class": ""
},
"submenu":
None,
})
menu.append({
"title":
_(u"shared_folder", default=u"Go to shared folder"),
"description":
_(u"description_shared_folder",
default=u"Show the language shared (neutral language) "
u"folder"),
"action":
shared_folder_url,
"selected":
False,
"icon":
None,
"extra": {
"id": "_shared_folder",
"separator": None,
"class": ""
},
"submenu":
None,
})
menu.append({
"title":
_(u"title_set_language", default=u"Set content language"),
"description":
_(u"description_set_language",
default=u"Set or change the current content language"),
"action":
url + "/update_language",
"selected":
False,
"icon":
None,
"extra": {
"id": "_set_language",
"separator": None,
"class": ""
},
"submenu":
None,
})
return menu
