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)