def ogcproxy(request):
url = request.params.get("url")
if url is None:
return HTTPBadRequest()
# check for full url
parsed_url = urlparse(url)
if not parsed_url.netloc or parsed_url.scheme not in ("http", "https"):
raise HTTPBadRequest()
# forward request to target (without Host Header)
http = Http(disable_ssl_certificate_validation=True)
h = dict(request.headers)
h.pop("Host", h)
try:
resp, content = http.request(url,
method=request.method,
body=request.body,
headers=h)
except:
raise HTTPBadGateway()
# All content types are allowed
if "content-type" in resp:
ct = resp["content-type"]
if resp["content-type"] == "application/vnd.google-earth.kmz":
zipfile = None
try:
zipurl = urlopen(url)
zipfile = ZipFile(StringIO(zipurl.read()))
content = ''
for line in zipfile.open(zipfile.namelist()[0]).readlines():
content = content + line
ct = 'application/vnd.google-earth.kml+xml'
except:
raise HTTPBadGateway()
finally:
if zipfile:
zipurl.close()
else:
raise HTTPNotAcceptable()
if content.find('encoding=') > 0:
m = re.search("encoding=\"(.*?)\\\"", content)
try:
data = content.decode(m.group(1))
except Exception:
raise HTTPNotAcceptable()
content = data.encode('utf-8')
content = content.replace(m.group(1), 'utf-8')
response = Response(content,
status=resp.status,
headers={"Content-Type": ct})
return response
def wms_structure(wms_url, host, request):
url = urlsplit(wms_url)
wms_url = add_url_params(wms_url, {
"SERVICE": "WMS",
"VERSION": "1.1.1",
"REQUEST": "GetCapabilities",
})
# Forward request to target (without Host Header)
headers = dict()
if url.hostname == "localhost" and host is not None: # pragma: no cover
headers["Host"] = host
try:
response = requests.get(wms_url,
headers=headers,
**request.registry.settings.get(
"http_options", {}))
except Exception: # pragma: no cover
raise HTTPBadGateway(
"Unable to GetCapabilities from wms_url {0!s}".format(wms_url))
if not response.ok: # pragma: no cover
raise HTTPBadGateway(
"GetCapabilities from wms_url {0!s} return the error: {1:d} {2!s}".
format(wms_url, response.status_code, response.reason))
try:
wms = WebMapService(None, xml=response.content)
result = {}
def _fill(name, parent):
if parent is None:
return
if parent.name not in result:
result[parent.name] = []
result[parent.name].append(name)
_fill(name, parent.parent)
for layer in list(wms.contents.values()):
_fill(layer.name, layer.parent)
return result
except AttributeError: # pragma: no cover
error = "WARNING! an error occurred while trying to " \
"read the mapfile and recover the themes."
error = "{0!s}\nurl: {1!s}\nxml:\n{2!s}".format(
error, wms_url, response.text)
log.exception(error)
raise HTTPBadGateway(error)
except SyntaxError: # pragma: no cover
error = "WARNING! an error occurred while trying to " \
"read the mapfile and recover the themes."
error = "{0!s}\nurl: {1!s}\nxml:\n{2!s}".format(
error, wms_url, response.text)
log.exception(error)
raise HTTPBadGateway(error)
def wms_structure(wms_url: Url, host: str,
request: pyramid.request.Request) -> Dict[str, List[str]]:
"""Get a simple serializable structure of the WMS capabilities."""
url = wms_url.clone().add_query({
"SERVICE": "WMS",
"VERSION": "1.1.1",
"REQUEST": "GetCapabilities"
})
# Forward request to target (without Host Header)
headers = {}
if url.hostname == "localhost" and host is not None:
headers["Host"] = host
try:
response = requests.get(url.url(),
headers=headers,
**request.registry.settings.get(
"http_options", {}))
except Exception:
LOG.exception("Unable to GetCapabilities from wms_url '%s'", wms_url)
raise HTTPBadGateway( # pylint: disable=raise-missing-from
"Unable to GetCapabilities, see logs for details")
if not response.ok:
raise HTTPBadGateway(
f"GetCapabilities from wms_url {url.url()} return the error: "
f"{response.status_code:d} {response.reason}")
try:
wms = WebMapService(None, xml=response.content)
result: Dict[str, List[str]] = {}
def _fill(name: str, parent: ContentMetadata) -> None:
if parent is None:
return
if parent.name not in result:
result[parent.name] = []
result[parent.name].append(name)
_fill(name, parent.parent)
for layer in list(wms.contents.values()):
_fill(layer.name, layer.parent)
return result
except AttributeError:
error = "WARNING! an error occurred while trying to read the mapfile and recover the themes."
error = f"{error}\nurl: {wms_url}\nxml:\n{response.text}"
LOG.exception(error)
raise HTTPBadGateway(error) # pylint: disable=raise-missing-from
except SyntaxError:
error = "WARNING! an error occurred while trying to read the mapfile and recover the themes."
error = f"{error}\nurl: {wms_url}\nxml:\n{response.text}"
LOG.exception(error)
raise HTTPBadGateway(error) # pylint: disable=raise-missing-from
def wms_structure(wms_url: Url, host: str, request: pyramid.request.Request) -> Dict[str, List[str]]:
url = wms_url.clone().add_query({"SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetCapabilities"})
# Forward request to target (without Host Header)
headers = dict()
if url.hostname == "localhost" and host is not None:
headers["Host"] = host
try:
response = requests.get(
url.url(), headers=headers, **request.registry.settings.get("http_options", {})
)
except Exception:
raise HTTPBadGateway("Unable to GetCapabilities from wms_url {}".format(wms_url))
if not response.ok:
raise HTTPBadGateway(
"GetCapabilities from wms_url {} return the error: {:d} {}".format(
url.url(), response.status_code, response.reason
)
)
try:
wms = WebMapService(None, xml=response.content)
result: Dict[str, List[str]] = {}
def _fill(name: str, parent: ContentMetadata) -> None:
if parent is None:
return
if parent.name not in result:
result[parent.name] = []
result[parent.name].append(name)
_fill(name, parent.parent)
for layer in list(wms.contents.values()):
_fill(layer.name, layer.parent)
return result
except AttributeError:
error = "WARNING! an error occurred while trying to read the mapfile and recover the themes."
error = "{0!s}\nurl: {1!s}\nxml:\n{2!s}".format(error, wms_url, response.text)
LOG.exception(error)
raise HTTPBadGateway(error)
except SyntaxError:
error = "WARNING! an error occurred while trying to read the mapfile and recover the themes."
error = "{0!s}\nurl: {1!s}\nxml:\n{2!s}".format(error, wms_url, response.text)
LOG.exception(error)
raise HTTPBadGateway(error)
def _wms_structure(wms_url, host):
url = urlsplit(wms_url)
wms_url = add_url_params(wms_url, {
"SERVICE": "WMS",
"VERSION": "1.1.1",
"REQUEST": "GetCapabilities",
})
log.info("Get WMS GetCapabilities for URL: %s" % wms_url)
# forward request to target (without Host Header)
http = httplib2.Http()
headers = dict()
if url.hostname == "localhost" and host is not None: # pragma: no cover
headers["Host"] = host
try:
resp, content = http.request(wms_url, method="GET", headers=headers)
except: # pragma: no cover
raise HTTPBadGateway("Unable to GetCapabilities from wms_url %s" % wms_url)
if resp.status < 200 or resp.status >= 300: # pragma: no cover
raise HTTPBadGateway(
"GetCapabilities from wms_url %s return the error: %i %s" %
(wms_url, resp.status, resp.reason)
)
try:
wms = WebMapService(None, xml=content)
result = {}
def _fill(name, parent):
if parent is None:
return
if parent.name not in result:
result[parent.name] = []
result[parent.name].append(name)
_fill(name, parent.parent)
for layer in wms.contents.values():
_fill(layer.name, layer.parent)
return result
except AttributeError: # pragma: no cover
error = "WARNING! an error occured while trying to " \
"read the mapfile and recover the themes."
error = "%s\nurl: %s\nxml:\n%s" % (error, wms_url, content)
log.exception(error)
raise HTTPBadGateway(error)
def _capabilities(self, templates, query_string, method):
# get URL
_url = self.config["print_url"] + "/capabilities.json"
resp, content = self._proxy(_url)
if self.request.method == "GET":
if resp.status == 200:
try:
capabilities = json.loads(content)
except json.JSONDecodeError as e:
# log and raise
log.error("Unable to parse capabilities.")
log.exception(e)
log.error(content)
raise HTTPBadGateway(content)
capabilities["layouts"] = list(
layout for layout in capabilities["layouts"]
if layout["name"] in templates)
pretty = self.request.params.get("pretty", "false") == "true"
content = json.dumps(capabilities,
separators=None if pretty else (",", ":"),
indent=4 if pretty else None)
else:
content = ""
return resp, content
def _capabilities(self, templates: List[str], query_string: Dict[str, str],
method: str,
referrer: str) -> Tuple[requests.Response, str]:
del query_string # Just for caching
del method # Just for caching
del referrer # Just for caching
# get URL
_url = self.request.get_organization_print_url() + "/capabilities.json"
response = self._proxy(Url(_url))
response.raise_for_status()
if self.request.method == "GET":
try:
capabilities = response.json()
except json.decoder.JSONDecodeError:
LOG.exception("Unable to parse capabilities: %s",
response.text)
raise HTTPBadGateway(response.text) # pylint: disable=raise-missing-from
capabilities["layouts"] = list(
layout for layout in capabilities["layouts"]
if layout["name"] in templates)
pretty = self.request.params.get("pretty", "false") == "true"
content = json.dumps(capabilities,
separators=None if pretty else (",", ":"),
indent=4 if pretty else None)
else:
content = ""
return response, content
def _capabilities(self, templates: List[str], query_string: Dict[str, str],
method: str) -> Tuple[requests.Response, str]:
del query_string # Just for caching
del method # Just for caching
# get URL
_url = self.config["print_url"] + "/capabilities.json"
response = self._proxy(_url)
if self.request.method == "GET":
if response.ok:
try:
capabilities = response.json()
except json.decoder.JSONDecodeError as e:
# log and raise
LOG.error("Unable to parse capabilities.")
LOG.exception(e)
LOG.error(response.text)
raise HTTPBadGateway(response.text)
capabilities["layouts"] = list(
layout for layout in capabilities["layouts"]
if layout["name"] in templates)
pretty = self.request.params.get("pretty", "false") == "true"
content = json.dumps(capabilities,
separators=None if pretty else (",", ":"),
indent=4 if pretty else None)
else:
content = ""
return response, content
def persona_login(request):
if request.method != 'POST':
return HTTPMethodNotAllowed('Only POST is allowed')
assertion = request.POST.get('assertion', None)
if assertion is None:
return HTTPBadRequest('The assertion parameter is required')
if 'next_url' in request.params and request.params['next_url']:
request.session['next_url'] = request.params['next_url']
settings = request.registry.settings
data = {
'assertion': assertion,
'audience': get_audience(settings['public_url_root'])
}
response = requests.post(settings['persona_verifier_url'],
data=data,
verify=True)
if response.ok:
verification_data = response.json()
if verification_data['status'] == 'okay':
email = verification_data['email']
info = {'email': email}
user_id = hashlib.sha1(email.encode('utf-8')).hexdigest()
return register_or_update(request, 'persona', user_id, info,
request.route_path('home'))
else:
return HTTPForbidden(
'Mozilla Persona verifier can not verify your identity')
else:
return HTTPBadGateway(
'Mozilla Persona verifier is not working properly')
def _get_capabilities_proxy(self, filter_, *args, **kwargs):
resp, content = self._proxy(*args, **kwargs)
if self.request.method == "GET":
if resp.status == 200:
try:
capabilities = json.loads(content)
except json.JSONDecodeError as e:
# log and raise
log.error("Unable to parse capabilities.")
log.exception(e)
log.error(content)
return HTTPBadGateway(content)
pretty = self.request.params.get("pretty", "false") == "true"
content = json.dumps(filter_(capabilities),
separators=None if pretty else (",", ":"),
indent=4 if pretty else None)
else:
content = ""
return self._build_response(
resp,
content,
PRIVATE_CACHE,
"print",
)
def devices_details_view(request):
device_id = request.matchdict["device_id"]
logger.debug("Getting details for device with ID=%s", device_id)
device_list_path = request.registry.settings['devices_path']
device = get_device(device_list_path, device_id)
# Only Philips Hue has device details at the moment
# TODO: In the future, each single Philips Hue light should be returned as a regular
# device. Philips Hue bridges should be flagged with `virtual: True` since they
# are not controlled by the user. However, all its lights should be returned as
# well when requesting `/devices`.
if device['type'] != 'philips_hue':
return {}
senic_hub_data_path = request.registry.settings.get(
"senic_hub_data_path", "/data/senic-hub")
phue_bridge_config = os.path.join(senic_hub_data_path,
'{}.conf'.format(device["id"]))
config = read_json(phue_bridge_config, {})
username = config.get(device["ip"], {}).get("username")
try:
bridge = PhilipsHueBridgeApiClient(device["ip"], username)
return bridge.get_lights()
# TODO create a tween to handle exceptions for all views
except UnauthenticatedDeviceError as e:
raise HTTPBadRequest(e.message)
except UpstreamError as e:
raise HTTPBadGateway(e.message)
def create(self):
""" Create PDF. """
# get query string
params = dict(self.request.params)
query_string = urllib.urlencode(params)
# get URL
_url = self.config['print_url'] + 'create.json' + '?' + query_string
log.info("Send print query to %s." % _url)
content_length = int(self.request.environ['CONTENT_LENGTH'])
body = self.request.environ['wsgi.input'].read(content_length)
# forward request to target (without Host Header)
http = httplib2.Http()
h = dict(self.request.headers)
if urlparse(_url).hostname != 'localhost':
h.pop('Host')
h['Content-Length'] = str(len(body))
try:
resp, content = http.request(_url,
method='POST',
body=body,
headers=h)
except:
return HTTPBadGateway()
return Response(content, status=resp.status, headers=dict(resp))
def get(self):
""" Get created PDF. """
file = self.request.matchdict.get('file')
# get URL
_url = self.config['print_url'] + file + '.printout'
log.info("Get print document from %s." % _url)
# forward request to target (without Host Header)
http = httplib2.Http()
h = dict(self.request.headers)
if urlparse(_url).hostname != 'localhost':
h.pop('Host')
try:
resp, content = http.request(_url, method='GET', headers=h)
except:
return HTTPBadGateway()
headers = {}
headers['content-type'] = resp['content-type']
headers['content-disposition'] = resp['content-disposition']
# remove Pragma and Cache-Control headers because of ie bug:
# http://support.microsoft.com/default.aspx?scid=KB;EN-US;q316431
#del response.headers['Pragma']
#del response.headers['Cache-Control']
return Response(content, status=resp.status, headers=headers)
def get_depatech_client():
request = get_current_request()
if hasattr(request, 'depatech_client'):
client = request.depatech_client
#logger.info('depa.tech request with username {0}'.format(client.username))
return client
else:
raise HTTPBadGateway('Datasource "depatech" not configured.')
def view_data(request):
s3 = S3Storage(keyname=request.registry.settings['data_js'],
bucketname=request.registry.settings['bucket'])
try:
content = s3.read()
except:
return HTTPBadGateway('Cannot connect or get data from backend')
return {"result": json.loads(content)}
def get_ificlaims_client():
request = get_current_request()
if hasattr(request, 'ificlaims_client'):
client = request.ificlaims_client
#logger.info('IFI CLAIMS request with username {0}'.format(client.username))
return client
else:
raise HTTPBadGateway('Datasource "ificlaims" not configured.')
def mobileconfig(self):
"""
View callable for the mobile application's config.js file.
"""
errors = []
mobile_default_themes = get_functionality('mobile_default_theme',
self.settings, self.request)
theme_name = self.request.params.get(
'theme', mobile_default_themes[0]
if len(mobile_default_themes) > 0 else None)
user = self.request.user
role_id = None if user is None else user.role.id
themes, errors = self._themes(role_id, True)
for t in themes:
self.flatten_layers(t)
# comma-separated string including the feature types supported
# by WFS service
wfs_types, errors = self._internal_wfs_types()
if len(errors) > 0: # pragma: no cover
raise HTTPBadGateway('\n'.join(errors))
wfs_types = ','.join(wfs_types)
# info includes various information that is not used by config.js,
# but by other - private to the integrator - parts of the mobile
# application.
info = {'username': user.username if user else ''}
# get the list of themes available for mobile
themes_ = []
themes, errors = self._themes(role_id, True)
for theme in themes:
# mobile theme or hidden theme explicitely loaded
if theme['inMobileViewer'] or theme['name'] == theme_name:
themes_.append({
'name': theme['name'],
'icon': theme['icon'],
'allLayers': theme['allLayers'],
'layers': theme['layers']
})
self.request.response.content_type = 'application/javascript'
return {
'lang': self.lang,
'themes': json.dumps(themes_),
'theme': theme_name if theme_name is not None else "",
'wfs_types': wfs_types,
'server_error': json.dumps(errors),
'info': json.dumps(info)
}
def __init__(self, api_uri, credentials=None, debug=False):
self.api_uri = api_uri
if credentials:
self.username = credentials['username']
self.password = credentials['password']
else:
message = u'No credentials configured for SIP API.'
logger.error(u'SipClientFactory: ' + message)
raise HTTPBadGateway(message)
def proxy(self):
url = self.request.params.get("url", "")
if not url.lower().startswith("http://"):
log.error("This service can only request HTTP protocol")
return HTTPBadGateway()
if not self._check_ip_for_httpsproxy(url):
log.error("Try to access an unathorized network")
log.error(url)
return HTTPUnauthorized()
params_dict = {}
for key in self.request.params.keys():
if not (key == "url"):
params_dict[key] = self.request.params.get(key)
params = urllib.urlencode(params_dict)
separator = "?"
if "?" in url:
separator = "&"
url = url + separator + params
timeout = 15
try:
f = urllib2.urlopen(url, None, timeout)
data = f.read()
except:
try:
# Retry to get the result
f = urllib2.urlopen(url, None, timeout)
data = f.read()
except Exception as e:
log.exception(e)
log.error(url)
return HTTPBadGateway()
headers = {"Content-Type": f.info()['Content-Type']}
return Response(data, headers=headers)
def __init__(self, credentials=None, debug=False):
if credentials:
self.consumer_key = credentials['consumer_key']
self.consumer_secret = credentials['consumer_secret']
else:
message = u'No credentials configured for OPS API.'
logger.error(u'OpsOAuthClientFactory: ' + message)
raise HTTPBadGateway(message)
if debug:
logging.getLogger('oauthlib').setLevel(logging.DEBUG)
def edit_tree(request):
logged_in = authenticated_userid(request)
keyname = request.registry.settings['data_js']
lock = Lock()
if request.method == 'GET':
s3 = S3Storage(keyname=keyname,
bucketname=request.registry.settings['bucket'])
lock_id = lock.acquire(keyname, duration=900, username=logged_in)
if lock_id:
try:
content = s3.read()
except:
return HTTPBadGateway(
'Cannot connect or get data from backend')
return {"result": json.loads(content)}
else:
return HTTPConflict('Resource is already locked')
elif request.method == 'POST':
try:
data = request.json
json_data = json.dumps(data)
except:
return HTTPBadRequest()
try:
s3 = S3Storage(keyname=request.registry.settings['data_js'],
bucketname=request.registry.settings['bucket'])
s3.write(json_data)
lock_id = lock.release(keyname)
except:
return HTTPBadGateway('Cannot connect or write data to backend')
return HTTPOk()
else:
return HTTPBadRequest()
def login(request):
client = oauth.Client(consumer)
oauth_callback_url = request.route_url('oauth_callback')
url = "%s?oauth_callback=%s" % (REQUEST_TOKEN_URL, oauth_callback_url)
resp, content = client.request(url, "GET")
if resp['status'] != '200':
return HTTPBadGateway('The OSM authentication server didn\'t\
respond correctly')
request_token = dict(urlparse.parse_qsl(content))
session = request.session
session['request_token'] = request_token
session['came_from'] = request.params.get('came_from')
redirect_url = "%s?oauth_token=%s" % \
(AUTHORIZE_URL, request_token['oauth_token'])
return HTTPFound(location=redirect_url)
def apijs(self):
wms, wms_errors = self._wms_getcap(
self.request.registry.settings['mapserv_url'])
if len(wms_errors) > 0:
raise HTTPBadGateway('\n'.join(wms_errors))
queryable_layers = [
name for name in list(wms.contents) if wms[name].queryable == 1
]
d = {
'lang': self.lang,
'debug': self.debug,
'queryable_layers': json.dumps(queryable_layers)
}
self.request.response.content_type = 'application/javascript'
return d
def get_metadata(self):
lang = self.request.params.get("lang", "fr")
langs = {'fr': 'fre',
'de': 'ger',
'en': 'eng',
'lb': 'ltz'}
id = self.request.params.get("uid", None)
callback_param = self.request.params.get("cb", None)
if id is None:
return HTTPBadRequest()
base_url = os.environ["GEONETWORK_BASE_URL"]
url = "{}/{}/q?_content_type=json&_isTemplate=y+or+n&_uuid_OR__id={}&fast=index".format(base_url, langs[lang], id)
timeout = 15
try:
f = urllib.request.urlopen(url, None, timeout)
data = json.loads(f.read())
except Exception as e:
log.exception(e)
log.error(url)
return HTTPBadGateway()
if lang != 'fr':
try:
url = "{}/{}/q?_content_type=json&_isTemplate=y+or+n&_uuid_OR__id={}&fast=index".format(base_url, langs["fr"], id)
f = urllib.request.urlopen(url, None, timeout)
data_fr = json.loads(f.read())
except Exception as e:
log.exception(e)
log.error(url)
if 'metadata' in data and 'responsibleParty' in data['metadata']:
if not isinstance(data['metadata']['responsibleParty'], type([])):
data['metadata']['responsibleParty'] = [data['metadata']['responsibleParty']]
if 'metadata' in data_fr and 'responsibleParty' in data_fr['metadata']:
if isinstance(data_fr['metadata']['responsibleParty'], type([])):
data['metadata']['responsibleParty'] = data['metadata']['responsibleParty'] + data_fr['metadata']['responsibleParty']
else:
if not 'responsibleParty' in data['metadata']:
data['metadata']['responsibleParty'] = []
data['metadata']['responsibleParty'].append(data_fr['metadata']['responsibleParty'])
if callback_param is None:
headers = {"Content-Type": f.info()['Content-Type']}
return Response(json.dumps(data), headers=headers)
headers = {"Content-Type": "text/javascript"}
return Response("{}({})".format(callback_param, json.dumps(data)), headers=headers)
def download_resource(self):
fid = self.request.params.get('fid', None)
attribute = self.request.params.get('attribute', None)
if fid is None or attribute is None:
return HTTPBadRequest("Request paramaters are missing")
layers, fid = fid.split('_', 1)
if layers is None:
return HTTPBadRequest("Request paramaters are missing")
luxgetfeaturedefinitions = self.get_lux_feature_definition(layers)
if len(luxgetfeaturedefinitions) == 0:
return HTTPBadRequest("Configuration is missing")
url = None
luxgetfeaturedefinition = luxgetfeaturedefinitions[0]
# TODO : Manage Database definition. Not only remote services.
if (luxgetfeaturedefinition is not None and
luxgetfeaturedefinition.rest_url is not None and
len(luxgetfeaturedefinition.rest_url) > 0):
features = self._get_external_data(
luxgetfeaturedefinition.layer,
luxgetfeaturedefinition.rest_url,
luxgetfeaturedefinition.id_column,
None, fid, None,
luxgetfeaturedefinition.attributes_to_remove,
luxgetfeaturedefinition.columns_order)
if attribute not in features[0]['attributes']:
return HTTPBadRequest("Bad attribute")
url = features[0]['attributes'][attribute]
if (url is None or not url.lower().startswith("http")):
return HTTPBadRequest("Attribute is not a valid url")
timeout = 15
try:
f = urllib2.urlopen(url, None, timeout)
data = f.read()
except:
try:
# Retry to get the result
f = urllib2.urlopen(url, None, timeout)
data = f.read()
except Exception as e:
log.exception(e)
log.error(url)
return HTTPBadGateway("Unable to access the remote url")
headers = {"Content-Type": f.info()['Content-Type']}
return Response(data, headers=headers)
def info(self):
""" Get print capabilities. """
templates = [
'1 A4 paysage', '2 A4 portrait', '3 A3 paysage', '4 A3 portrait'
]
# get query string
params = dict(self.request.params)
query_string = urllib.urlencode(params)
# get URL
_url = self.request.registry.settings[
'print_url'] + 'info.json' + '?' + query_string
log.info("Get print capabilities from %s." % _url)
# forward request to target (without Host Header)
http = httplib2.Http()
h = dict(self.request.headers)
if urlparse(_url).hostname != 'localhost':
h.pop('Host')
try:
resp, content = http.request(_url, method='GET', headers=h)
except:
return HTTPBadGateway()
try:
capabilities = json.loads(content)
except JSONDecodeError:
# log and raise
log.error("Unable to parse capabilities.")
log.info(content)
return content
capabilities['layouts'] = list(layout
for layout in capabilities['layouts']
if layout['name'] in templates)
headers = dict(resp)
del headers['content-length']
headers["Expires"] = "-1"
headers["Pragma"] = "no-cache"
headers["CacheControl"] = "no-cache"
return Response(json.dumps(capabilities, separators=(',', ':')),
status=resp.status,
headers=headers)
def __init__(self,
api_uri,
api_uri_json=None,
credentials=None,
debug=False):
self.api_uri = api_uri
self.api_uri_json = api_uri_json
if credentials:
self.username = credentials['username']
self.password = credentials['password']
else:
message = u'No credentials configured for IFI CLAIMS API.'
logger.error(u'IFIClaimsClientFactory: ' + message)
raise HTTPBadGateway(message)
def devices_details_view(request):
device_id = int(request.matchdict["device_id"])
logger.debug("Getting details for device with ID=%s", device_id)
device_list_path = request.registry.settings['devices_path']
device = get_device(device_list_path, device_id)
config = read_json(request.registry.settings["hass_phue_config_path"], {})
username = (config.get(device["ip"]) or {}).get("username")
bridge = PhilipsHueBridge(device["ip"], username)
try:
return bridge.get_lights()
# TODO create a tween to handle exceptions for all views
except UnauthenticatedDeviceError as e:
raise HTTPBadRequest(e.message)
except UpstreamError as e:
raise HTTPBadGateway(e.message)
def apijs(self):
role_id = None if self.request.user is None \
else self.request.user.role.id
wms, wms_errors = self._wms_getcap(
self.request.registry.settings['mapserv_url'], role_id)
if len(wms_errors) > 0: # pragma: no cover
raise HTTPBadGateway('\n'.join(wms_errors))
queryable_layers = [
name for name in list(wms.contents) if wms[name].queryable == 1
]
d = {
'lang': self.lang,
'debug': self.debug,
'queryable_layers': json.dumps(queryable_layers),
'tiles_url': json.dumps(self.settings.get("tiles_url")),
}
self.request.response.content_type = 'application/javascript'
return d
def _info(self, templates):
# get query string
params = dict(self.request.params)
query_string = urllib.urlencode(params)
# get URL
_url = self.config['print_url'] + 'info.json' + '?' + query_string
log.info("Get print capabilities from %s." % _url)
# forward request to target (without Host Header)
http = httplib2.Http()
h = dict(self.request.headers)
if urlparse(_url).hostname != 'localhost':
h.pop('Host')
try:
resp, content = http.request(_url, method='GET', headers=h)
except:
return HTTPBadGateway()
try:
capabilities = json.loads(content)
except JSONDecodeError:
# log and raise
log.error("Unable to parse capabilities.")
log.info(content)
return content
capabilities['layouts'] = list(layout
for layout in capabilities['layouts']
if layout['name'] in templates)
headers = dict(resp)
del headers['content-length']
response = Response(
json.dumps(capabilities, separators=(',', ':')),
status=resp.status,
headers=headers,
)
response.cache_control.public = True
response.cache_control.max_age = \
self.request.registry.settings["default_max_age"]
return response