def publishTraverse(self, request, name):
""" used for traversal via publisher, i.e. when using as a url """
stack = request.get('TraversalRequestNameStack')
if stack and stack[-1] not in self._ignored_stacks:
# field and scale name were given...
scale = stack.pop()
image = self.scale(name, scale) # this is aq-wrapped
elif '.' in name:
# we got a uid...
uid, ext = name.rsplit('.', 1)
storage = AnnotationStorage(self.context)
info = storage.get(uid)
image = None
if info is not None:
image = self.make(info).__of__(self.context)
alsoProvides(image, IStableImageScale)
else:
# otherwise `name` must refer to a field...
scale_view = self.get_image_scale_view()
if not scale_view:
raise NotFound(self, name, self.request)
return scale_view.scale()
if image is not None:
return image
raise NotFound(self, name, self.request)
def initialize(self):
if not self.names:
self.action = self.INDEX
return
path, ext = os.path.splitext(self.traversed_path)
# We need to route requests with build/js in them to the combo loader
# js files so we can load those to bootstap.
if path.startswith('build/js'):
self.action = self.COMBOFILE
else:
full_path = os.path.join(config.root, 'lib', path)
if not os.path.exists(full_path + '.py'):
raise NotFound(self, full_path + '.py', self.request)
if not os.path.exists(full_path + '.js'):
raise NotFound(self, full_path + '.js', self.request)
if ext == '.js':
self.action = self.JAVASCRIPT
else:
if self.request.method == 'GET':
self.action = self.HTML
else:
self.fixtures = self.request.form['fixtures'].split(',')
if self.request.form['action'] == 'setup':
self.action = self.SETUP
else:
self.action = self.TEARDOWN
def __call__(self):
# TODO: Security check on form view/widget
if self.context.ignoreContext:
raise NotFound(
"Cannot get the data file from a widget with no context")
if self.context.form is not None:
content = aq_inner(self.context.form.getContent())
else:
content = aq_inner(self.context.context)
field = aq_inner(self.context.field)
dm = getMultiAdapter((
content,
field,
), IDataManager)
file_ = dm.get()
if file_ is None:
raise NotFound(self, self.filename, self.request)
if not self.filename:
self.filename = getattr(file_, 'filename', None)
set_headers(file_, self.request.response, filename=self.filename)
return stream_data(file_)
def _getFile(self):
logger.info("got download request for " + self.context.absolute_url())
if utils.isJwtEnabled():
token = utils.getTokenFromHeader(self.request)
if (not token):
raise Exception('Expected JWT')
utils.decodeSecurityToken(token)
utils.checkSecurityToken(self.context,
utils.getTokenFromRequest(self.request))
if not self.fieldname:
info = IPrimaryFieldInfo(self.context, None)
if info is None:
# Ensure that we have at least a fieldname
raise NotFound(self, '', self.request)
self.fieldname = info.fieldname
file = info.value
if file is None:
raise NotFound(self, self.fieldname, self.request)
return file
def get(self, name, default=_marker):
for pat in self.forbidden_names:
if fnmatch.fnmatch(name, pat):
if default is _marker:
raise NotFound(None, name)
else:
return default
path = self.context.path
filename = os.path.join(path, name)
isfile = os.path.isfile(filename)
isdir = os.path.isdir(filename)
if not (isfile or isdir):
if default is _marker:
raise NotFound(None, name)
return default
if isfile:
ext = os.path.splitext(os.path.normcase(name))[1][1:]
factory = queryUtility(IResourceFactoryFactory, ext,
self.default_factory)
else:
factory = self.directory_factory
rname = self.__name__ + '/' + name
resource = factory(filename, self.context.checker, rname)(self.request)
resource.__parent__ = self
return resource
def constraintregion(self):
uuid = self.request.form.get('uuid')
exp = uuidToObject(uuid)
if not exp:
self.record_error('Not Found', 404, 'Experiment not found',
{'parameter': 'uuid'})
raise NotFound(self, 'constraintregion', self.request)
downloadurl = None
if IExperiment.providedBy(exp):
downloadurl = '{}/@@download/modelling_region.json'.format(
exp.absolute_url())
elif not IExperiment.providedBy(exp.__parent__):
# this is an exp result file, so get exp folder
exp = exp.__parent__
if IExperiment.providedBy(exp.__parent__):
# This is an exp result folder
if IProjectionExperiment.providedBy(exp.__parent__):
if exp.job_params['projection_region']:
downloadurl = '{}/@@download/modelling_region.json'.format(
exp.absolute_url())
else:
# Get constraint from SDM experiment result file.
# Use the modelling_region.json file in the sdm result if available.
if not 'species_distribution_models' in exp.job_params:
self.record_error(
'NotFound', 404, 'SDM model not found',
{'parameter': 'species_distribution_models'})
raise NotFound(self, 'species_distribution_models',
self.request)
sdmuuid = exp.job_params['species_distribution_models']
sdmobj = uuidToObject(sdmuuid).__parent__
# Return the modelling_region attribute only if no modelling_region.json file
if not 'modelling_region.json' in sdmobj.keys():
downloadurl = '{}/@@download/modelling_region.json'.format(
sdmobj.absolute_url())
else:
# Redirect to download the modelling_region.json
constraint_region = sdmobj.get('modelling_region.json')
remoteUrl = getattr(constraint_region, 'remoteUrl',
None)
if remoteUrl is None:
raise NotFound(self, 'remoteUrl', self.request)
# Generate temp url
tool = getUtility(ISwiftUtility)
try:
downloadurl = tool.generate_temp_url(url=remoteUrl)
except:
downloadurl = remoteUrl
else:
downloadurl = '{}/@@download/modelling_region.json'.format(
exp.absolute_url())
if downloadurl is None:
self.record_error('Not Found', 404, 'Constraint region not found',
{'parameter': 'uuid'})
raise NotFound(self, 'constraintregion', self.request)
return self.request.RESPONSE.redirect(downloadurl.encode('utf-8'))
def publishTraverse(self, context, name):
# no serviceid yet ? .... name should be it
if not self._serviceid:
providers = getUtility(IVocabularyFactory,
'org.bccvl.site.oauth.providers')(
self.context)
registry = getUtility(IRegistry)
for term in providers:
coll = registry.collectionOfInterface(term.value)
if name in coll:
config = coll[name]
self._serviceid = name
if IOAuth1Settings.providedBy(config):
self._view = OAuth1View(self.context, self.request,
config)
elif IOAuth2Settings.providedBy(config):
self._view = OAuth2View(self.context, self.request,
config)
else:
# give other providers a chance
continue
return self
# raise NotFound (we didn't return earlier)
raise NotFound(self, name, self.request)
else:
# we have a serviceid ... name should now be a command
if name in ('authorize', 'callback', 'accesstoken', 'clienttoken',
'cleartoken'):
return getattr(self._view, name)
raise NotFound(self, name, self.request)
def monkeypatch_plone_formwidget_namedfile_widget_download__call__(self):
""" Patches to plone.formwidget.namedfile.widget.Download.__call__
"""
if self.context.ignoreContext:
raise NotFound(
'Cannot get the data file from a widget with no context')
if self.context.form is not None:
content = aq_inner(self.context.form.getContent())
else:
content = aq_inner(self.context.context)
field = aq_inner(self.context.field)
dm = getMultiAdapter((
content,
field,
), IDataManager)
file_ = dm.get()
if file_ is None:
raise NotFound(self, self.filename, self.request)
if not self.filename:
self.filename = getattr(file_, 'filename', None)
set_headers(file_, self.request.response, filename=self.filename)
if IBlobby.providedBy(file):
zodb_blob = file_._blob
else:
zodb_blob = file_
if set_xsendfile_header(self.request, self.request.response,
zodb_blob):
return 'collective.xsendfile - proxy missing?'
else:
return stream_data(file_)
def rat(self):
uuid = self.request.form.get('uuid')
layer = self.request.form.get('layer')
brain = None
try:
brain = uuidToCatalogBrain(uuid)
except Exception as e:
LOG.error('Caught exception %s', e)
if not brain:
self.record_error('Not Found', 404, 'dataset not found',
{'parameter': 'uuid'})
raise NotFound(self, 'metadata', self.request)
md = IBCCVLMetadata(brain.getObject())
if not layer and layer not in md.get('layers', {}):
self.record_error('Bad Request', 400, 'Missing parameter layer',
{'parameter': 'layer'})
raise BadRequest('Missing parameter layer')
try:
rat = md.get('layers', {}).get(layer, {}).get('rat')
rat = json.loads(unicode(rat))
return rat
except Exception as e:
LOG.warning(
"Couldn't decode Raster Attribute Table from metadata. %s: %s",
self.context, repr(e))
raise NotFound(self, 'rat', self.request)
def publishTraverse(self, request, name):
""" used for traversal via publisher, i.e. when using as a url """
stack = request.get('TraversalRequestNameStack')
image = None
if stack and stack[-1] not in self._ignored_stacks:
# field and scale name were given...
scale = stack.pop()
image = self.scale(name, scale) # this is an aq-wrapped scale_view
if image:
return image
elif '-' in name:
# we got a uid...
if '.' in name:
name, ext = name.rsplit('.', 1)
storage = AnnotationStorage(self.context)
info = storage.get(name)
if info is None:
raise NotFound(self, name, self.request)
scale_view = ImageScale(self.context, self.request, **info)
alsoProvides(scale_view, IStableImageScale)
return scale_view
else:
# otherwise `name` must refer to a field...
if '.' in name:
name, ext = name.rsplit('.', 1)
value = getattr(self.context, name)
scale_view = ImageScale(
self.context,
self.request,
data=value,
fieldname=name,
)
return scale_view
raise NotFound(self, name, self.request)
def __call__(self):
""" Partially reproduced from plone.formwidget.namedfile.widget.Download.
Leverages the existing BlobWrapper functionality to stream the media blobs
to the client, allowing ranges and partial content.
"""
if self.context.ignoreContext:
raise NotFound(
"Cannot get the data file from a widget with no context")
if self.context.form is not None:
content = aq_inner(self.context.form.getContent())
else:
content = aq_inner(self.context.context)
field = aq_inner(self.context.field)
dm = getMultiAdapter((
content,
field,
), IDataManager)
file_ = dm.get()
if file_ is None:
raise NotFound(self, self.request)
content_type = get_contenttype(file_)
blob_wrapper = BlobWrapper(content_type)
blob_wrapper.setBlob(file_)
return blob_wrapper.index_html(self.request)
def traverseName(self, request, ob, name):
nm = name # the name to look up the object with
if name and name[:1] in '@+':
# Process URI segment parameters.
ns, nm = nsParse(name)
if ns:
try:
ob2 = namespaceLookup(ns, nm, ob, request)
except TraversalError:
raise NotFound(ob, name)
return self.proxy(ob2)
if nm == '.':
return ob
if IPublishTraverse.providedBy(ob):
ob2 = ob.publishTraverse(request, nm)
else:
# self is marker
adapter = queryMultiAdapter((ob, request), IPublishTraverse,
default=self)
if adapter is not self:
ob2 = adapter.publishTraverse(request, nm)
else:
raise NotFound(ob, name, request)
return self.proxy(ob2)
def traverse(self, name):
"""Traverse the paths of a feed.
If a query string is provided it is normalized. 'bugs' paths and
persons ('~') are special cased.
"""
# Normalize the query string so caching is more effective. This is
# done by simply sorting the entries.
# XXX bac 20071019, we would like to normalize with respect to case
# too but cannot due to a problem with the bug search requiring status
# values to be of a particular case. See bug 154562.
query_string = self.request.get('QUERY_STRING', '')
fields = sorted(query_string.split('&'))
normalized_query_string = '&'.join(fields)
if query_string != normalized_query_string:
# We must empty the traversal stack to prevent an error
# when calling RedirectionView.publishTraverse().
self.request.setTraversalStack([])
target = "%s%s?%s" % (self.request.getApplicationURL(),
self.request['PATH_INFO'],
normalized_query_string)
redirect = RedirectionView(target, self.request, 301)
return redirect
# Handle the two formats of urls:
# http://feeds.launchpad.net/bugs/+bugs.atom?...
# http://feeds.launchpad.net/bugs/1/bug.atom
if name == 'bugs':
stack = self.request.getTraversalStack()
if len(stack) == 0:
raise NotFound(self, '', self.request)
bug_id = stack.pop()
if bug_id.startswith('+'):
if config.launchpad.is_bug_search_feed_active:
return getUtility(IBugTaskSet)
else:
raise Unauthorized("Bug search feed deactivated")
else:
self.request.stepstogo.consume()
return getUtility(IBugSet).getByNameOrID(bug_id)
# Redirect to the canonical name before doing the lookup.
if canonical_name(name) != name:
return self.redirectSubTree(canonical_url(self.context) +
canonical_name(name),
status=301)
try:
if name.startswith('~'):
# Handle persons and teams.
# http://feeds.launchpad.net/~salgado/latest-bugs.html
person = getUtility(IPersonSet).getByName(name[1:])
return person
else:
# Otherwise, handle products, projects, and distros
return getUtility(IPillarNameSet)[name]
except NotFoundError:
raise NotFound(self, name, self.request)
def publishTraverse(self, request, name):
if self.method is None:
if name == 'callback':
self.method = name
else:
raise NotFound(self, name, request)
else:
raise NotFound(self, name, request)
return self
def __call__(self):
# respect field level security as defined in plone.autoform
# check if attribute access would be allowed!
# url = guarded_getattr(self.context, 'remoteUrl', None)
exp = self.context
if IProjectionExperiment.providedBy(exp):
if exp.projection_region:
return exp.projection_region.data
if not exp.species_distribution_models:
raise NotFound(self, 'species_distribution_models', self.request)
# Return the SDM's modelling region
sdmuuid = exp.species_distribution_models.keys()[0]
sdmobj = uuidToObject(sdmuuid)
if sdmobj and sdmobj.modelling_region:
return sdmobj.modelling_region.data
elif IExperiment.providedBy(exp):
if exp.modelling_region:
return exp.modelling_region.data
else:
# Move one level up if this is an exp result file
if not IExperiment.providedBy(exp.__parent__):
exp = exp.__parent__
if IExperiment.providedBy(exp.__parent__):
# this is the result folder
if IProjectionExperiment.providedBy(exp.__parent__):
if exp.job_params['projection_region']:
return exp.job_params['projection_region'].data
# Get constraint from SDM experiment result file.
# Use the modelling_region.json file in the sdm result if available.
if not 'species_distribution_models' in exp.job_params:
raise NotFound(self, 'species_distribution_models', self.request)
sdmuuid = exp.job_params['species_distribution_models']
sdmobj = uuidToObject(sdmuuid).__parent__
else:
sdmobj = exp
# Return the modelling_region attribute only if no modelling_region.json file
if not 'modelling_region.json' in sdmobj.keys():
return sdmobj.modelling_region.data
# Redirect to download the modelling_region.json
constraint_region = sdmobj.get('modelling_region.json')
remoteUrl = getattr(constraint_region, 'remoteUrl', None)
if remoteUrl is None:
raise NotFound(self, 'remoteUrl', self.request)
# Generate temp url
tool = getUtility(ISwiftUtility)
try:
url = tool.generate_temp_url(url=remoteUrl)
except:
url = remoteUrl
return self.request.RESPONSE.redirect(url.encode('utf-8'))
else:
raise NotFound(self, 'constraint_region', self.request)
def publishTraverse(self, request, name):
if name == '.':
return self.context
if name.startswith('._'):
raise NotFound(self.context, name, request)
if name.startswith('++field++'):
return self.traverse(name[9:], None)
raise NotFound(self.context, name, request)
def _getFile(self):
if not self.fieldname:
raise NotFound(self, '', self.request)
else:
data = self.context.data[self.fieldname]
if data:
filename = self.filename and self.filename or 'Download'
set_headers(data, self.request.response, filename)
else:
raise NotFound(self, None, self.request)
return data
def nullResource(self, request, name):
# we traversed to something that doesn't exist.
# The name must be the last name in the path, so the traversal
# name stack better be empty:
if request.getTraversalStack():
raise NotFound(self.context, name, request)
# This should only happen for a PUT or MKCOL:
if request.method not in ['PUT', 'MKCOL']:
raise NotFound(self.context, name, request)
return NullResource(self.context, name)
def publishTraverse(self, request, name):
# URL routing for SAML2 endpoints
# /saml2/idp/sso -> Process AuthNRequest and issue SAMLResponse
# /saml2/sp/sso -> Process SAMLResponse and authenticate user
if self.party is None:
if name in {'idp', 'sp'}:
self.party = name
else:
raise NotFound(self, name, request)
elif self.service is None:
if name != 'sso':
raise NotFound(self, name, request)
self.service = name
return self
def get(self, name, default=_not_found):
"""
Locate *name* on the filesystem and return a `.IResource` for
it.
If the *name* cannot be found and no *default* is given, then
raise `.NotFound`.
If the *name* matches one of the :attr:`forbidden patterns
<forbidden_names>` then returns the *default* (if given) or
raise `.NotFound` (when not given).
When the *name* refers to a file, we `query <.queryUtility>`
for a `.IResourceFactoryFactory` utility named for the file's
extension (e.g., ``css``) and use it to produce a resource.
If no such utility can be found, we use :attr:`our default
<default_factory>`.
When the *name* refers to a directory, we use :attr:`our
directory factory <directory_factory>`.
"""
for pat in self.forbidden_names:
if fnmatch.fnmatch(name, pat):
if default is _not_found:
raise NotFound(None, name)
return default
path = self.context.path
filename = os.path.join(path, name)
isfile = os.path.isfile(filename)
isdir = os.path.isdir(filename)
if not (isfile or isdir):
if default is _not_found:
raise NotFound(None, name)
return default
if isfile:
ext = os.path.splitext(os.path.normcase(name))[1][1:]
factory = queryUtility(IResourceFactoryFactory, ext,
self.default_factory)
else:
factory = self.directory_factory
rname = self.__name__ + '/' + name
resource = factory(filename, self.context.checker, rname)(self.request)
resource.__parent__ = self
return resource
def __call__(self):
# Ensure that we have at least a filedname
if not self.fieldname:
raise NotFound(self, '', self.request)
file = getattr(self.context, self.fieldname, None)
if file is None:
raise NotFound(self, self.fieldname, self.request)
if not self.filename:
self.filename = getattr(file, 'filename', self.fieldname)
set_headers(file, self.request.response, filename=self.filename)
return stream_data(file)
def __call__(self):
if self.context.ignoreContext:
raise NotFound(
'Cannot get the data file from a widget with no context.', )
context = self.context.context
field = self.context.field
dm = getMultiAdapter((context, field), IDataManager)
file_ = dm.query()
if file_ is None:
raise NotFound(self, self.filename, self.request)
if not self.filename:
self.filename = getattr(file_, 'filename', None)
set_headers(file_, self.request.response, filename=self.filename)
return stream_data(file_)
def _traverse(self, request, name):
adapter = queryAdapter(self.context, self.interface,
name=self.adapterName)
if adapter is None:
raise NotFound(self.context, name, request)
return adapter
def publishTraverse(self, request, name):
if self.scale is None:
# ../@@scaling/scale
self.scale = name
else:
raise NotFound(self, name, request)
return self
def publishTraverse(self, request, name):
if self.filename is None:
# ../@@download/filename
self.filename = name
else:
raise NotFound(self, name, request)
return self
def publishTraverse(self, request, name):
""" used for traversal via publisher, i.e. when using as a url """
stack = request.get('TraversalRequestNameStack')
image = None
if stack:
# field and scale name were given...
scale = stack.pop()
image = self.scale(name, scale) # this is aq-wrapped
elif '-' in name:
# we got a uid...
if '.' in name:
name, ext = name.rsplit('.', 1)
storage = AnnotationStorage(self.context)
info = storage.get(name)
if info is not None:
scale_view = ImageScale(self.context, self.request, **info)
return scale_view.__of__(self.context)
else:
# otherwise `name` must refer to a field...
if '.' in name:
name, ext = name.rsplit('.', 1)
value = self.context.data.get(name)
scale_view = ImageScale(self.context,
self.request,
data=value,
fieldname=name)
return scale_view.__of__(self.context)
if image is not None:
return image
raise NotFound(self, name, self.request)
def publishTraverse(self, request, name):
if self.method is None:
method = getattr(self, 'do_' + name, None)
if method is not None and callable(method):
self.method = 'do_' + name
return self
raise NotFound(self, name, request)
def callback(self, state=None, return_url=None):
if not self.is_callback():
# TODO: maybe rais some other error here?
raise NotFound(self.context, 'callback', self.request)
# get current state to verify callback
state, return_url = self.session.get(self._skey)
# verify oauth callback
oauth = self.oauth_session(state=state)
# TODO: there should be a better way to get the full request url
authorization_response = self.request.getURL() + '?' + self.request['QUERY_STRING']
# the request must have some auth_response somewhere?
# NOTE: since oauthlib 0.7.2 which correctly compares scope
# we need export OAUTHLIB_RELAX_TOKEN_SCOPE=1 or catch the Warning
# otherwise google login won't work
# We no longer need 'state' after we have parsed the response url
token = oauth.fetch_token(
self.config.token_url,
authorization_response=authorization_response,
# Google specific extra parameter used for client
# authentication
client_secret=self.config.client_secret)
# store token and clean up session
if self.session.has_key(self._skey):
del self.session[self._skey]
self.setToken(token)
# Do another redirect to clean up the url
self.request.response.redirect(return_url or self.request.getURL())
def publishTraverse(self, request, name):
try:
obj = getattr(self.context, name)
except AttributeError:
raise NotFound(self.context, name, request)
else:
return obj
def publishTraverse(self, request, name):
"""See zope.publisher.interfaces.IPublishTraverse"""
subob = self.context.get(name, None)
if subob is None:
raise NotFound(self.context, name, request)
return subob
