def translateArtists(language="en"):
import plone.api
import transaction
from plone.app.multilingual.interfaces import ITranslationManager
container_path = "/nl/online-archief/kunstenaars"
with plone.api.env.adopt_user(username="******"):
container = plone.api.content.get(path=container_path)
total = len(list(container))
curr = 0
for _id in list(container):
curr += 1
print "Translating Person %s / %s to '%s'" %(curr, total, language)
person = container[_id]
if not ITranslationManager(person).has_translation(language):
ITranslationManager(person).add_translation(language)
person_translated = ITranslationManager(person).get_translation(language)
person_translated.title = person.title
person_translated.firstname = person.firstname
person_translated.lastname = person.lastname
person_translated.nationality = person.nationality
person_translated.year = person.year
person_translated.reindexObject()
transaction.get().commit()
print "Translation added for Person '%s'" %(person.title)
else:
print "Person '%s' already has a translation to '%s'" %(person.title, language)
return True
def check_translation_exists(self, video, language):
has_translation = ITranslationManager(video).has_translation(language)
if has_translation:
translated_video = ITranslationManager(video).get_translation(language)
return translated_video
else:
return False
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 create_person_translation(self, person, language):
ITranslationManager(person).add_translation(language)
translated_person = ITranslationManager(person).get_translation(
language)
translated_person = self.copy_fields_to_translation(
person, translated_person)
return translated_person
def copy_related_fields(self, obj, target_languages):
# XXX: Where is this used?
try:
fields = schema.getFieldsInOrder(obj.getTypeInfo().lookupSchema())
except AttributeError as e:
log.info("Error: %s" % "/".join(obj.getPhysicalPath()))
log.exception(e)
pcat = api.portal.get_tool("portal_catalog")
for key, value in fields:
value = value.get(obj)
if isinstance(value, list):
manager = ITranslationManager(obj)
for language in target_languages:
translated_obj = manager.get_translation(language)
uid_list = []
for uid in value:
element = pcat(UID=uid, Language=obj.Language())
if element:
manager = ITranslationManager(
element[0].getObject()) # noqa
element_trans = manager.get_translation(language)
if element_trans:
uid_list.append(IUUID(element_trans))
if uid_list:
setattr(translated_obj, key, uid_list)
translated_obj.reindexObject()
def check_translation_exists(self, person, language):
has_translation = ITranslationManager(person).has_translation(language)
if has_translation:
translated_person = ITranslationManager(person).get_translation(
language)
return translated_person
else:
return False
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_register_translation(self):
a_es = createContentInContainer(self.portal['es'],
'Document',
title=u"Test document")
ITranslationManager(self.a_ca).register_translation('es', a_es)
translations = ITranslationManager(self.a_ca).get_translations()
self.assertEqual(translations, {'ca': self.a_ca, 'es': a_es})
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 setUp(self):
self.portal = self.layer["portal"]
self.portal_url = self.portal.absolute_url()
self.request = self.layer["request"]
self.api_session = RelativeSession(self.portal_url, test=self)
self.api_session.headers.update({"Accept": "application/json"})
self.api_session.auth = (SITE_OWNER_NAME, SITE_OWNER_PASSWORD)
alsoProvides(self.layer["request"], IPloneAppMultilingualInstalled)
login(self.portal, SITE_OWNER_NAME)
self.en_content = createContentInContainer(self.portal["en"],
"Document",
title="Test document")
self.es_content = createContentInContainer(self.portal["es"],
"Document",
title="Test document")
ITranslationManager(self.en_content).register_translation(
"es", self.es_content)
self.folder = createContentInContainer(self.portal["es"],
"Folder",
id="folder",
title="Some Folder")
createContentInContainer(self.folder,
"Document",
id="doc1",
title="A document")
transaction.commit()
def get_all_translations(self, content):
"""Return all translations excluding the just modified content"""
content_lang = queryAdapter(content, ILanguage).get_language()
translations = ITranslationManager(content).get_translated_languages()
while content_lang in translations:
translations.remove(content_lang)
return 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)
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 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 add_subscriber(self, context, fields):
request = self.request
alsoProvides(request, IDisableCSRFProtection)
form = EasyFormForm(context, request)
form.updateFields()
form.updateWidgets()
data, errors = form.extractData()
period_id = data.get("period")
if isinstance(period_id, list):
period_id = period_id[0]
period = context.aq_parent.get(period_id)
title = "{0} {1}".format(data.get("last_name"), data.get("first_name"))
subscriber = api.content.create(
container=period, type="subscriber", title=title
)
self.add_subscriber_in_period(context, period, subscriber, form, data)
if not IPloneAppMultilingualInstalled.providedBy(request):
return
registry = getUtility(IRegistry)
langs = list(registry['plone.available_languages'])
current_lang = api.portal.get_current_language()[:2]
langs.remove(current_lang)
for lang in langs:
trans = ITranslationManager(period).get_translation(lang)
if trans:
new_subscriber = api_lng.translate(subscriber, lang)
new_subscriber.title = title
self.add_subscriber_in_period(context, trans, new_subscriber, form, data)
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 set_translation_map(self):
""" Set position of container object given by `id` and `position` """
from plone.protect.interfaces import IDisableCSRFProtection
from zope.interface import alsoProvides
from plone.app.multilingual.interfaces import ITranslationManager
alsoProvides(self.request, IDisableCSRFProtection)
translation_map = json.loads(self.request.BODY)
for translations in translation_map:
if "en" not in translations or "de" not in translations:
continue
source_obj = self.context.restrictedTraverse(
str(translations["de"]["path"]), None)
translated_obj = self.context.restrictedTraverse(
str(translations["en"]["path"]), None)
if source_obj is not None and translated_obj is not None:
print(translations)
manager = ITranslationManager(source_obj)
try:
manager.register_translation(translated_obj.language,
translated_obj)
except KeyError as e:
print(e)
self.request.response.setStatus(200)
def set_translation(self, original_path, translation_path,
target_language):
""" Set position of container object given by `id` and `position` """
from plone.protect.interfaces import IDisableCSRFProtection
from zope.interface import alsoProvides
from plone.app.multilingual.interfaces import ITranslationManager
alsoProvides(self.request, IDisableCSRFProtection)
source_obj = self.context.restrictedTraverse(original_path, None)
if source_obj is None:
raise ValueError("No object found at {}".format(original_path))
translated_obj = self.context.restrictedTraverse(
translation_path, None)
if translated_obj is None:
raise ValueError("No object found at {}".format(translation_path))
translated_obj.language = target_language
translated_obj.reindexObject()
manager = ITranslationManager(source_obj)
manager.register_translation(translated_obj.language, translated_obj)
self.request.response.setStatus(200)
def setContentsInActionMenu(self, value):
self.settings.contents_in_action_menu = value
portal = root = api.portal.get()
if "fr" in root.objectIds():
fr = getattr(root, "fr")
root = api.portal.get_navigation_root(fr)
catalog = api.portal.get_tool("portal_catalog")
name = "cpskin.core.vocabularies.action_menu_eligible"
factory = getUtility(IVocabularyFactory, name)
vocabulary = factory(portal)
all_values = vocabulary.by_value.keys()
for content_id in all_values:
content = getattr(root, content_id, None)
if not content:
continue
translations = {"fr": content}
request = getattr(self.context, "REQUEST", None)
if is_plone_app_multilingual_installed(request):
translations = ITranslationManager(content).get_translations()
if content_id in value:
for t in translations.values():
if IElectedContentForTopMenu.providedBy(t):
continue
alsoProvides(t, IElectedContentForTopMenu)
catalog.reindexObject(t)
else:
for t in translations.values():
if not IElectedContentForTopMenu.providedBy(t):
continue
noLongerProvides(t, IElectedContentForTopMenu)
catalog.reindexObject(t)
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 __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 copy_relation(self, relation_value, target_language):
obj = relation_value.to_object
intids = getUtility(IIntIds)
translation = ITranslationManager(obj).get_translation(target_language)
if translation:
return RelationValue(intids.getId(translation))
else:
return RelationValue(intids.getId(obj))
def link_translations(request, registration):
if not IPloneAppMultilingualInstalled.providedBy(request):
return
if not IRegistration.providedBy(registration):
return
if not ITranslatable.providedBy(registration):
return
registry = getUtility(IRegistry)
langs = list(registry["plone.available_languages"])
current_lang = api.portal.get_current_language()[:2]
langs.remove(current_lang)
types = ["EasyForm", "Event"]
for lang in langs:
trans_registration = ITranslationManager(registration).get_translation(
lang)
if not trans_registration:
continue
for portal_type in types:
brains = api.content.find(context=registration,
portal_type=portal_type)
if len(brains) != 1:
continue
obj = brains[0].getObject()
if not ITranslatable.providedBy(obj):
continue
trans = ITranslationManager(obj).get_translation(lang)
if trans:
continue
trans_brains = api.content.find(
context=trans_registration,
portal_type=portal_type,
)
if len(trans_brains) != 1:
continue
trans_obj = trans_brains[0].getObject()
ITranslationManager(obj).register_translation(lang, trans_obj)
ILanguage(trans_obj).set_language(lang)
def __call__(self):
language = self.request.get('language', None)
if language:
context = aq_inner(self.context)
translation_manager = ITranslationManager(context)
new_parent = translation_manager.add_translation_delegated(language) # noqa
baseUrl = new_parent.absolute_url()
url = '%s/++addtranslation++%s' % (baseUrl, IUUID(context))
return self.request.response.redirect(url)
