def remove(self, resource_name): """ Remove a resource by path/name """ if self.is_readonly: raise zExceptions.Forbidden(_('Connector is readonly')) subpath = safe_unicode(self.request.get('subpath', self.subpath)) handle = self.context.get_handle() if not handle.exists(resource_name): msg = 'Not found {}'.format(resource_name) raise zExceptions.NotFound(msg) if handle.isdir(resource_name): try: handle.removetree(resource_name) except Exception as e: msg = resource_name + _(' could not be deleted') + ' ({})'.format(e) self.request.response.setStatus(500) return msg elif handle.isfile(resource_name): try: handle.remove(resource_name) except Exception as e: msg = _('{} could not be deleted ({})').format(resource_name, e) self.request.response.setStatus(500) return msg else: msg = _('Unhandled file type for {}').format(resource_name) raise RuntimeError(msg) msg = _('Deleted {}').format(resource_name) self.request.response.setStatus(200)
def __call__(self): """ Download given file """ handle = self.context.get_handle() filename = self.subpath if not handle.exists(filename): raise zExceptions.NotFound('{} does not exist'.format(filename)) basename = os.path.basename(filename) basename, ext = os.path.splitext(basename) mt, encoding = mimetypes.guess_type(filename) self.request.response.setHeader('content-type', mt) if 'download' in self.request.form or 'filename' in self.request.form: fn = self.request.get('filename', os.path.basename(filename)) self.request.response.setHeader( 'content-disposition', 'attachment; filename="{}"'.format(fn)) content_length = handle.getsize(filename) if content_length: self.request.response.setHeader('content-length', str(content_length)) return connector_iterator(handle, filename) else: with handle.open(filename, 'rb') as fp: data = fp.read() self.request.response.setHeader('content-length', str(len(data))) return data
def __call__(self, *args, **kw): qs = self.request.QUERY_STRING user = getSecurityManager().getUser() # request/force_default_view can be used to force a redirect to the # default anonymous view force_default_view = self.request.form.get('force_default_view', 0) if force_default_view: if user.has_permission(permissions.View, self.context): default_view = self.context.default_view_anonymous if qs: default_view += '?' + qs return self.request.response.redirect('{}/{}'.format( self.context.absolute_url(), default_view)) else: LOG.error( u'Unable to redirect to anonymous default view of ({}, {})' .format(user.getUserName(), self.context.absolute_url(1))) raise zExceptions.NotFound() if user.has_permission(permissions.ModifyPortalContent, self.context): default_view = self.context.default_view_authenticated if qs: default_view += '?' + qs return self.request.response.redirect('{}/{}'.format( self.context.absolute_url(), default_view)) else: default_view = self.context.default_view_anonymous if default_view: if qs: default_view += '?' + qs return self.request.response.redirect('{}/{}'.format( self.context.absolute_url(), default_view)) else: msg = _(u'No default view configured for anonymous visitors') self.context.plone_utils.addPortalMessage(msg, 'error') raise zExceptions.NotFound()
def __call__(self, *args, **kw): user = getSecurityManager().getUser() if user.has_permission(permissions.ModifyPortalContent, self.context): default_view = self.context.default_view_authenticated return self.request.response.redirect( '{}/{}'.format(self.context.absolute_url(), default_view)) else: default_view = self.context.default_view_anonymous if default_view: return self.request.response.redirect( '{}/{}'.format(self.context.absolute_url(), default_view)) else: msg = _(u'No default view configured for anonymous visitors') self.context.plone_utils.addPortalMessage(msg, 'error') raise zExceptions.NotFound()
def __bobo_traverse__(self, request, entryname): """ Traversal hook for (un)restrictedTraverse() """ self.traversal_subpath.append(entryname) traversal_subpath = '/'.join(self.traversal_subpath) handle = self.webdav_handle() if handle.exists(traversal_subpath): if handle.isdir(traversal_subpath): return self elif handle.isfile(traversal_subpath): data = handle.open(traversal_subpath, 'rb').read() self.wrapped_object = data self.wrapped_info = handle.getinfo(traversal_subpath) try: self.wrapped_meta = handle.getmeta(traversal_subpath) except fs.errors.NoMetaError: self.wrapped_meta = None return self raise zExceptions.NotFound('not found: {}'.format(entryname))
def content(self, path=None): if not path: path = self.path app_id = path[0] app = get_app(app_id, self.request) method = getattr(IDisplay(app), self.method) try: (result, redirect) = method(path, self.request) except NotAllowed: raise zExceptions.BadRequest() except NotFound: raise zExceptions.NotFound() except Unauthorized: raise unauth("Not authorized") self.store_app_messages(app) if redirect: self.request.RESPONSE.redirect(redirect) else: return result
def remote_exists(self, path): """ Check if `path` exists based on our own traversal. The purpose of this method is to provide a traversal lookup that is not dependent on Acquisition but on real traversal. E.g. a request to `/plone/papers/conference/papers` would resolve to the first `papers` folder if the second `papers` folder does not exist. """ # current = self.context.restrictedTraverse("/") current = plone.api.portal.get() for c in path.split("/"): if not c: continue if c in current.objectIds(): current = current[c] else: raise zExceptions.NotFound(path) self.request.response.setStatus(200)
def get_handle(self, subpath=None, root=False): """ Returns a webdav handle for the current subpath """ if not root: if not subpath: subpath = '/'.join(self.subpath) try: return self.context.get_handle(subpath) except fs.errors.ResourceNotFoundError as e: msg = 'eXist-db path {} does not exist'.format(e.url) self.context.plone_utils.addPortalMessage(msg, 'error') LOG.debug(msg) raise zExceptions.NotFound() except fs.errors.PermissionDeniedError as e: msg = 'eXist-db path {} unauthorized access (check credentials)'.format( e.url) self.context.plone_utils.addPortalMessage(msg, 'error') LOG.error(msg) raise zExceptions.Unauthorized()
def _render(self): name = self.request.form.get('name') if not name: raise ValueError('Parameter "name" is missing') mt, encoding = mimetypes.guess_type(os.path.basename(name)) handle = self.context.get_handle(create_if_not_existing=True) if handle.exists(name): fp = handle.open(name, 'rb') size = handle.getsize(name) self.request.response.setHeader('content-length', str(size)) self.request.response.setHeader('content-type', mt) self.request.response.setHeader( 'content-disposition', 'attachment; filename={}'.format(os.path.basename(name))) return fs_filestream_iterator(fp) else: self.request.response.setStatus(403) raise zExceptions.NotFound(u'Not found: {}'.format(name))
def __bobo_traverse__(self, request, entryname): """ Traversal hook for (un)restrictedTraverse() """ self.traversal_subpath.append(entryname) traversal_subpath = '/'.join(self.traversal_subpath) handle = self.get_handle() if six.PY2: traversal_subpath = unicode(traversal_subpath, 'utf8') if handle.exists(traversal_subpath): if handle.isdir(traversal_subpath): return self elif handle.isfile(traversal_subpath): with handle.open(traversal_subpath, 'rb') as fp: data = fp.read() self.wrapped_object = data self.wrapped_info = handle.getinfo(traversal_subpath, namespaces=['access', 'details']) try: self.wrapped_meta = handle.getmeta(traversal_subpath) except fs.errors.NoMetaError: self.wrapped_meta = None return self raise zExceptions.NotFound('not found: {}'.format(entryname))
def get_handle(self, subpath=None, create_if_not_existing=False): """ Return WebDAV handle to root of configured connector object including configured connector_subpath. """ registry = getUtility(IRegistry) settings = registry.forInterface(IConnectorSettings) adapted = IConnector(self) url = adapted.connector_url or settings.connector_url if adapted.connector_subpath: url += '/{}'.format(adapted.connector_subpath) if subpath: url += '/{}'.format(urllib.quote(subpath)) # system-wide credentials username = settings.connector_username password = settings.connector_password or '' # local credentials override the system credentials if adapted.connector_url: username = adapted.connector_username or '' password = adapted.connector_password or '' if create_if_not_existing: util = getUtility(IConnectorHandle) handle = util.get_handle() if not handle.exists(adapted.connector_subpath): handle.makedir(adapted.connector_subpath, recursive=True) url = '{}/{}'.format(handle.url.strip('/'), adapted.connector_subpath) try: return get_fs_wrapper(url, credentials=dict(username=username, password=password), context=self) except fs.errors.ResourceNotFoundError: LOG.warn(u'Error accessing {}::{}::{}'.format( self.absolute_url(), url, self.REQUEST.get('HTTP_USER_AGENT')), exc_info=True) raise zExceptions.NotFound(url) except fs.errors.ResourceInvalidError: parts = url.rsplit('/', 1) wrapper = get_fs_wrapper(parts[0], credentials=dict( username=username, password=password), context=self) wrapper.__leaf__ = True wrapper.__leaf_filename__ = parts[1] return wrapper except fs.errors.RemoteConnectionError as e: # LOG.error(u'Error accessing {}::{}::{}'.format( # self.absolute_url(), # url, # self.REQUEST.get('HTTP_USER_AGENT')), # exc_info=True) exc = RuntimeError(url) exc.url = url raise exc except Exception as e: print repr(e) LOG.warn(u'Error accessing {}::{}::{}'.format( self.absolute_url(), url, self.REQUEST.get('HTTP_USER_AGENT')), exc_info=True) e.url = url raise e