def get_remote_url(self): """ Resolve uid and return ref absolute url """ if ILink.providedBy(self.context): value = getattr(self.context, "remoteUrl", "") else: value = self.context.getRemoteUrl if not value: return "" if value.startswith("http"): # it isn't an internal link, so we can return it return value path = replace_link_variables_by_paths(context=self.context, url=value) match = RESOLVEUID_RE.match(path) if match: uid, suffix = match.groups() return uuidToURL(uid) else: portal = api.portal.get() try: ref_obj = portal.restrictedTraverse(path, None) if ref_obj: return ref_obj.absolute_url() except Exception: return "" return ""
def absolute_target_url(self, urlstring): """Compute the absolute target URL.""" url = urlstring # self.url(obj, attributename) if self._url_uses_scheme(NON_RESOLVABLE_URL_SCHEMES, url): return url if url.startswith('.'): # we just need to adapt ../relative/links, /absolute/ones work # anyway -> this requires relative links to start with ./ or # ../ context_state = self.context.restrictedTraverse( '@@plone_context_state') url = '/'.join([context_state.canonical_object_url(), url]) else: if not url.startswith(('http://', 'https://')): # url = self.request['SERVER_URL'] + url if 'resolveuid/' in url: try: uuid = url.split("resolveuid/")[1] url = uuidToURL(uuid) except Exception: pass else: url = api.portal.get().absolute_url() + url return url
def __call__(self): value = copy.deepcopy(self.get_value()) # Resolve UID links if self.field.getName() == "blocks": for block in value.values(): if block.get("@type") == "text": entity_map = block.get("text", {}).get("entityMap", {}) for entity in entity_map.values(): if entity.get("type") == "LINK": href = entity.get("data", {}).get("url", "") before = href # noqa if href: match = RESOLVEUID_RE.match(href) if match is not None: uid, suffix = match.groups() href = uuidToURL(uid) if href is None: continue if suffix: href += "/" + suffix entity["data"]["href"] = href entity["data"]["url"] = href print("SERIALIZE " + before + " -> " + href) # noqa return json_compatible(value)
def test_uuidToURL_permission(self): from plone.outputfilters.browser.resolveuid import uuidToURL from plone.outputfilters.browser.resolveuid import uuidToObject self.portal.invokeFactory('Document', id='page', title='Page') page = self.portal['page'] self.logout() self.assertEqual('http://nohost/plone/page', uuidToURL(page.UID())) self.assertTrue(page.aq_base is uuidToObject(page.UID()).aq_base)
def test_uuidToURL_permission(self): from plone.outputfilters.browser.resolveuid import uuidToURL from plone.outputfilters.browser.resolveuid import uuidToObject self.portal.invokeFactory("Document", id="page", title="Page") page = self.portal["page"] self.logout() self.assertEqual("http://nohost/plone/page", uuidToURL(page.UID())) self.assertTrue(page.aq_base is uuidToObject(page.UID()).aq_base)
def __call__(self): if self.field.getName() != "remoteUrl": return super(TextLineFieldSerializer, self).__call__() value = self.get_value() path = replace_link_variables_by_paths(context=self.context, url=value) match = RESOLVEUID_RE.match(path) if match: uid, suffix = match.groups() value = uuidToURL(uid) else: portal = getMultiAdapter((self.context, self.context.REQUEST), name="plone_portal_state").portal() ref_obj = portal.restrictedTraverse(path, None) if ref_obj: value = ref_obj.absolute_url() return json_compatible(value)
def get_remote_url(self): if ILink.providedBy(self.context): value = getattr(self.context, "remoteUrl", "") else: value = self.context.getRemoteUrl if not value: return "" path = replace_link_variables_by_paths(context=self.context, url=value) match = RESOLVEUID_RE.match(path) if match: uid, suffix = match.groups() return uuidToURL(uid) else: portal = getMultiAdapter( (self.context, self.context.REQUEST), name="plone_portal_state" ).portal() ref_obj = portal.restrictedTraverse(path, None) if ref_obj: return ref_obj.absolute_url() return value
def uid_to_url(path): if not path: return "" match = RESOLVEUID_RE.match(path) if match is None: return path uid, suffix = match.groups() href = uuidToURL(uid) if href is None: return path if suffix: href += "/" + suffix else: target_object = uuidToObject(uid) if target_object: adapter = queryMultiAdapter((target_object, target_object.REQUEST), IObjectPrimaryFieldTarget) if adapter and adapter(): href = adapter() return href
def storeImagesLocally(context, xhtmlContent, imagePortalType='Image', store_external_images=True, store_internal_images=True, pretty_print=False, force_resolve_uid=False): """If images are found in the given p_xhtmlContent, we download it and stored it in p_context, this way we ensure that it will always be available in case the external/internal image image disappear. If p_store_external_images is True, we retrieve external image and store it in p_context, if p_store_internal_images is True, we do the same for internal images.""" def _handle_internal_image(img_src): """ """ # get image from URL img_path = img_src.replace(portal_url, '') img_path = path.join(portal.absolute_url_path(), img_path) # path can not start with a '/' img_path = img_path.lstrip('/') # right, traverse to image try: imageObj = portal.unrestrictedTraverse(img_path) except (KeyError, AttributeError): # wrong img_path logger.warning('In \'storeImagesLocally\', could not traverse ' 'img_path \'{0}\' for \'{1}\'!'.format( img_path, context.absolute_url())) return None, None # not an image if getattr(imageObj, 'portal_type', None) != 'Image': return None, None filename = imageObj.getId() data = imageObj.getBlobWrapper().data return filename, data def _handle_external_image(img_src): """ """ # right, we have an external image, download it, stores it in context and update img_src try: downloaded_img_path, downloaded_img_infos = urllib.urlretrieve( img_src) except IOError: # url not existing return None, None # not an image if not downloaded_img_infos.maintype == 'image': return None, None # retrieve filename filename = 'image' disposition = downloaded_img_infos.getheader('Content-Disposition') # get real filename from 'Content-Disposition' if available if disposition: disp_value, disp_params = cgi.parse_header(disposition) filename = disp_params.get('filename', 'image') # if no 'Content-Disposition', at least try to get correct file extension elif hasattr(downloaded_img_infos, 'subtype'): filename = '{0}.{1}'.format(filename, downloaded_img_infos.subtype) f = open(downloaded_img_path, 'r') data = f.read() f.close() # close and delete temporary file if path.exists(downloaded_img_path): os.remove(downloaded_img_path) return filename, data tree = _turnToLxmlTree(xhtmlContent) if not isinstance(tree, lxml.html.HtmlElement): return xhtmlContent imgs = tree.findall('.//img') if not imgs: return xhtmlContent portal = api.portal.get() portal_url = portal.absolute_url() # make sure context_url ends with a '/' to avoid mismatch if folder holding the # image absolute_url starts with context_url context_url = context.absolute_url() + '/' # adapter to generate a valid id, it needs a container, so it will be context or it's parent try: name_chooser = INameChooser(context) except TypeError: parent = context.getParentNode() name_chooser = INameChooser(parent) # return received xhtmlContent if nothing was changed changed = False for img in imgs: original_img_src = img.get('src', '') # we only handle http stored images if not original_img_src.startswith( 'http') and 'resolveuid' not in original_img_src: continue filename = data = None # external images if store_external_images and not original_img_src.startswith(portal_url) and \ 'resolveuid' not in original_img_src: filename, data = _handle_external_image(original_img_src) # image in portal but not already stored in context # handle images using resolveuid end_of_url = None img_src = original_img_src if 'resolveuid' in original_img_src: # manage cases like : # - resolveuid/2ff7ea3317df43438a09edfa84965b13 # - resolveuid/2ff7ea3317df43438a09edfa84965b13/image_preview # - http://portal_url/resolveuid/2ff7ea3317df43438a09edfa84965b13 img_uid = original_img_src.split('resolveuid/')[-1].split('/')[0] # save end of url if any, like /image_preview end_of_url = original_img_src.split(img_uid)[-1] if end_of_url == img_uid: end_of_url = None # if not found, like when copy/paste HTML code containing resolveuid, use '' instead None img_src = uuidToURL(img_uid) or '' if store_internal_images and \ img_src.startswith(portal_url) and \ not img_src.startswith(context_url): filename, data = _handle_internal_image(img_src) if not filename: continue changed = True # create image name = name_chooser.chooseName(filename, context) new_img_id = context.invokeFactory(imagePortalType, id=name, title=name, file=data) new_img = getattr(context, new_img_id) # store a resolveuid if using it, the absolute_url to image if not if force_resolve_uid or \ original_img_src.startswith('resolveuid') or \ (HAS_CKEDITOR and hasattr(portal.portal_properties, 'ckeditor_properties') and portal.portal_properties.ckeditor_properties.allow_link_byuid): new_img_src = 'resolveuid/{0}'.format(new_img.UID()) else: new_img_src = new_img.absolute_url() if end_of_url: new_img_src = '/'.join([new_img_src, end_of_url.strip('/')]) img.attrib['src'] = new_img_src if not changed: return xhtmlContent return ''.join([ lxml.html.tostring(x, encoding='utf-8', pretty_print=pretty_print, method='html') for x in tree.iterchildren() ])
def __call__(self): return uuidToURL(self.uuid)
def test_uuidToURL(self): from plone.outputfilters.browser.resolveuid import uuidToURL self.assertEqual('http://nohost/plone/image.jpg', uuidToURL(self.UID))
def test_uuidToURL(self): from plone.outputfilters.browser.resolveuid import uuidToURL self.assertEqual('http://nohost/plone/image.jpg', uuidToURL(self.UID))