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 _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 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 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 __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 __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):
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 __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 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 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 _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 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 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 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 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 translated_urls(context):
manager = ITranslationManager(context)
translated_languages = manager.get_translated_languages()
content_language = ILanguage(context).get_language()
if content_language in translated_languages:
translated_languages.remove(content_language)
languages = []
for lang in translated_languages:
languages.append(SimpleVocabulary.createTerm(lang, lang, \
manager.get_translation(lang).absolute_url()))
return SimpleVocabulary(languages)
def get_all_translations(self, content):
"""Return all translations excluding the just modified content"""
translations_list_to_process = []
content_lang = queryAdapter(content, ILanguage).get_language()
canonical = ITranslationManager(content)
translations = canonical.get_translations()
for language in translations.keys():
if language != content_lang:
translations_list_to_process.append(translations[language])
return translations_list_to_process
def 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 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 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 __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 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 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
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 get_all_events(self, batch=True):
# Fall back to default language for local events
kw = {}
default_lang = api.portal.get_tool(
"portal_languages").getDefaultLanguage()
if ITranslatable.providedBy(self.context):
if default_lang != self.context.Language():
portal = getSite()
trans = ITranslationManager(
self.context).get_translation(default_lang)
root = getNavigationRootObject(trans, portal)
kw['path'] = '/'.join(root.getPhysicalPath())
kw['Language'] = [default_lang, '']
start, end = self._start_end
sort = 'start'
sort_reverse = False
if self.mode in ('past', 'all'):
sort_reverse = True
expand = True
local_events = get_events(self.context,
start=start,
end=end,
sort=sort,
review_state='published',
sort_reverse=sort_reverse,
ret_mode=RET_MODE_ACCESSORS,
expand=expand,
**kw)
remote_events = self._remote_events()
reverse = self.mode == 'past'
all_events = sorted(local_events + remote_events,
key=lambda x: x.start,
reverse=reverse)
if batch:
b_start = self.b_start
b_size = self.b_size
res = Batch(all_events,
size=b_size,
start=b_start,
orphan=self.orphan)
else:
res = all_events
return res
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 handle_modified(self, content):
canonical = ITranslationManager(content).query_canonical()
if canonical in self.stack:
return
else:
self.stack.append(canonical)
# Copy over all language independent fields
translations = self.get_all_translations(content)
manager = ILanguageIndependentFieldsManager(content)
for translation in translations:
manager.copy_fields(translation)
# fti = getUtility(IDexterityFTI, name=content.portal_type)
# schema = fti.lookupSchema()
schema = content.Schema()
descriptions = Attributes(schema)
self.reindex_translations(translations, descriptions)
self.stack.remove(canonical)
