def test_add_url_params_port(self): presult = urlparse( add_url_params("http://example.com:8480/toto", {"1": "2"})) self.assertEqual(presult.scheme, "http") self.assertEqual(presult.netloc, "example.com:8480") self.assertEqual(presult.path, "/toto") self.assertEqual(presult.params, "") self.assertEqual(presult.fragment, "") self.assertEqual(parse_qs(presult.query), {"1": ["2"]})
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 test_add_url_params_encode2(self): presult = urlparse( add_url_params("http://example.com/toto?à=é", {"1": "2"})) self.assertEqual(presult.scheme, "http") self.assertEqual(presult.netloc, "example.com") self.assertEqual(presult.path, "/toto") self.assertEqual(presult.params, "") self.assertEqual(presult.fragment, "") self.assertEqual(parse_qs(presult.query), {"à": ["é"], "1": ["2"]})
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", }) # 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 Exception: # pragma: no cover raise HTTPBadGateway("Unable to GetCapabilities from wms_url {0!s}".format(wms_url)) if resp.status < 200 or resp.status >= 300: # pragma: no cover raise HTTPBadGateway( "GetCapabilities from wms_url {0!s} return the error: {1:d} {2!s}".format( 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 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, content) 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, content) log.exception(error) raise HTTPBadGateway(error)
def test_add_url_params_encode1(self): presult = urlparse(add_url_params( "http://example.com/toto", {"à": "é"} )) self.assertEqual(presult.scheme, "http") self.assertEqual(presult.netloc, "example.com") self.assertEqual(presult.path, "/toto") self.assertEqual(presult.params, "") self.assertEqual(presult.fragment, "") self.assertEqual(parse_qs(presult.query), { "à": ["é"], })
def test_add_url_params_port(self): presult = urlparse(add_url_params( "http://example.com:8480/toto", {"1": "2"} )) self.assertEqual(presult.scheme, "http") self.assertEqual(presult.netloc, "example.com:8480") self.assertEqual(presult.path, "/toto") self.assertEqual(presult.params, "") self.assertEqual(presult.fragment, "") self.assertEqual(parse_qs(presult.query), { "1": ["2"], })
def _fill_legend_rule_query_string(layer_theme, layer, url): if layer.legend_rule and url: layer_theme["icon"] = add_url_params( url, { "SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetLegendGraphic", "LAYER": layer.name, "FORMAT": "image/png", "TRANSPARENT": "TRUE", "RULE": layer.legend_rule, }, )
def test_add_url_params(self): from c2cgeoportal_geoportal.lib import add_url_params from urllib.parse import urlparse, parse_qs params = {"Name": "Bob", "Age": 18, "Nationality": "Việt Nam"} result = add_url_params("http://test/", params) presult = urlparse(result) self.assertEqual(presult.scheme, "http") self.assertEqual(presult.netloc, "test") self.assertEqual(presult.path, "/") self.assertEqual(presult.params, "") self.assertEqual(presult.fragment, "") self.assertEqual( parse_qs(presult.query), {"Name": ["Bob"], "Age": ["18"], "Nationality": ["Việt Nam"]} )
def test_add_url_params(self): from c2cgeoportal_geoportal.lib import add_url_params from urllib.parse import urlparse, parse_qs params = {"Name": "Bob", "Age": 18, "Nationality": "Việt Nam"} result = add_url_params("http://test/", params) presult = urlparse(result) self.assertEqual(presult.scheme, "http") self.assertEqual(presult.netloc, "test") self.assertEqual(presult.path, "/") self.assertEqual(presult.params, "") self.assertEqual(presult.fragment, "") self.assertEqual(parse_qs(presult.query), { "Name": ["Bob"], "Age": ["18"], "Nationality": ["Việt Nam"], })
async def _wms_get_features_type(self, wfs_url, preload=False): errors = set() params = { "SERVICE": "WFS", "VERSION": "1.0.0", "REQUEST": "DescribeFeatureType", "ROLE_ID": "0", "USER_ID": "0", } wfs_url = add_url_params(wfs_url, params) LOG.debug("WFS DescribeFeatureType for base url: %s", wfs_url) # forward request to target (without Host Header) headers = dict(self.request.headers) if urllib.parse.urlsplit( wfs_url).hostname != "localhost" and "Host" in headers: headers.pop("Host") # pragma nocover try: response = await asyncio.get_event_loop().run_in_executor( None, get_http_cached, self.http_options, wfs_url, headers) except Exception: # pragma: no cover errors.add("Unable to get DescribeFeatureType from URL {}".format( wfs_url)) return None, errors if not response.ok: # pragma: no cover errors.add( "DescribeFeatureType from URL {} return the error: {:d} {}". format(wfs_url, response.status_code, response.reason)) return None, errors if preload: return None, errors try: return lxml.XML(response.text.encode("utf-8")), errors except Exception as e: # pragma: no cover errors.add( "Error '{}' on reading DescribeFeatureType from URL {}:\n{}". format(str(e), wfs_url, response.text)) return None, errors
def _layer_attributes(self, url, layer): errors = set() request = _Request() request.registry.settings = self.config # Static schema will not be supported url = get_url2("Layer", url, request, errors) if len(errors) > 0: print("\n".join(errors)) return [], [] url, headers, kwargs = self._build_url(url) if url not in self.wmscap_cache: print("Get WMS GetCapabilities for URL: {}".format(url)) self.wmscap_cache[url] = None wms_getcap_url = add_url_params( url, { "SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetCapabilities", }) try: print("Get WMS GetCapabilities for URL {},\nwith headers: {}". format(wms_getcap_url, " ".join(["=".join(h) for h in headers.items()]))) response = requests.get(wms_getcap_url, headers=headers, **kwargs) try: self.wmscap_cache[url] = WebMapService( None, xml=response.content) except Exception as e: print( colorize( "ERROR! an error occurred while trying to " "parse the GetCapabilities document.", RED)) print(colorize(str(e), RED)) print("URL: {}\nxml:\n{}".format(wms_getcap_url, response.text)) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") != "TRUE": raise except Exception as e: # pragma: no cover print(colorize(str(e), RED)) print( colorize( "ERROR! Unable to GetCapabilities from URL: {},\nwith headers: {}" .format( wms_getcap_url, " ".join(["=".join(h) for h in headers.items()])), RED, )) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") != "TRUE": raise wmscap = self.wmscap_cache[url] if url not in self.featuretype_cache: print("Get WFS DescribeFeatureType for URL: {}".format(url)) self.featuretype_cache[url] = None wfs_descrfeat_url = add_url_params( url, { "SERVICE": "WFS", "VERSION": "1.1.0", "REQUEST": "DescribeFeatureType", }) try: response = requests.get(wfs_descrfeat_url, headers=headers, **kwargs) except Exception as e: # pragma: no cover print(colorize(str(e), RED)) print( colorize( "ERROR! Unable to DescribeFeatureType from URL: {}". format(wfs_descrfeat_url), RED, )) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [], [] else: raise if not response.ok: # pragma: no cover print( colorize( "ERROR! DescribeFeatureType from URL {} return the error: {:d} {}" .format(wfs_descrfeat_url, response.status_code, response.reason), RED, )) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [], [] else: raise Exception("Aborted") try: describe = parseString(response.text) featurestype = {} self.featuretype_cache[url] = featurestype for type_element in describe.getElementsByTagNameNS( "http://www.w3.org/2001/XMLSchema", "complexType"): featurestype[type_element.getAttribute( "name")] = type_element except ExpatError as e: print( colorize( "ERROR! an error occurred while trying to " "parse the DescribeFeatureType document.", RED)) print(colorize(str(e), RED)) print("URL: {}\nxml:\n{}".format(wfs_descrfeat_url, response.text)) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [], [] else: raise except AttributeError: print( colorize( "ERROR! an error occurred while trying to " "read the Mapfile and recover the themes.", RED)) print("URL: {}\nxml:\n{}".format(wfs_descrfeat_url, response.text)) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [], [] else: raise else: featurestype = self.featuretype_cache[url] if featurestype is None: return [], [] layers = [layer] if wmscap is not None and layer in list(wmscap.contents): layer_obj = wmscap[layer] if len(layer_obj.layers) > 0: layers = [l.name for l in layer_obj.layers] attributes = [] for sub_layer in layers: # Should probably be adapted for other king of servers type_element = featurestype.get("{}Type".format(sub_layer)) if type_element is not None: for element in type_element.getElementsByTagNameNS( "http://www.w3.org/2001/XMLSchema", "element"): if not element.getAttribute("type").startswith("gml:"): attributes.append(element.getAttribute("name")) return attributes, layers
def test_add_url_params_noparam(self): self.assertEqual(add_url_params("http://example.com/", {}), "http://example.com/")
def test_add_url_params_noparam(self): self.assertEqual(add_url_params( "http://example.com/", {} ), "http://example.com/")
def _layer_attributes(self, url, layer): errors = set() class Registry: setting = None class Request: registry = Registry() request = Request() request.registry.settings = self.config # static schema will not be supported url = get_url2("Layer", url, request, errors) if len(errors) > 0: print("\n".join(errors)) return [] wms_getcap_url = add_url_params(url, { "SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetCapabilities", }) hostname = urlsplit(url).hostname if url not in self.wmscap_cache: print("Get WMS GetCapabilities for URL: {}".format(url)) self.wmscap_cache[url] = None # forward request to target (without Host Header) http = httplib2.Http() h = {} if hostname == "localhost": # pragma: no cover h["Host"] = self.package["host"] try: resp, content = http.request(wms_getcap_url, method="GET", headers=h) try: self.wmscap_cache[url] = WebMapService(None, xml=content) except Exception as e: print( colorize( "ERROR! an error occurred while trying to " "parse the GetCapabilities document.", RED)) print(colorize(str(e), RED)) print("URL: {}\nxml:\n{}".format(wms_getcap_url, content)) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") != "TRUE": raise except Exception as e: # pragma: no cover print(colorize(str(e), RED)) print( colorize( "ERROR! Unable to GetCapabilities from URL: {}".format( wms_getcap_url), RED, )) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") != "TRUE": raise wmscap = self.wmscap_cache[url] wfs_descrfeat_url = add_url_params( url, { "SERVICE": "WFS", "VERSION": "1.1.0", "REQUEST": "DescribeFeatureType", }) if url not in self.featuretype_cache: print("Get WFS DescribeFeatureType for URL: {}".format( wfs_descrfeat_url)) self.featuretype_cache[url] = None # forward request to target (without Host Header) http = httplib2.Http() h = {} if hostname == "localhost": # pragma: no cover h["Host"] = self.package["host"] try: resp, content = http.request(wfs_descrfeat_url, method="GET", headers=h) except Exception as e: # pragma: no cover print(colorize(str(e), RED)) print( colorize( "ERROR! Unable to DescribeFeatureType from URL: {}". format(wfs_descrfeat_url), RED, )) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [] else: raise if resp.status < 200 or resp.status >= 300: # pragma: no cover print( colorize( "ERROR! DescribeFeatureType from URL {} return the error: {1:d} {}" .format(wfs_descrfeat_url, resp.status, resp.reason), RED, )) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [] else: raise Exception("Aborted") try: describe = parseString(content) featurestype = {} self.featuretype_cache[url] = featurestype for type_element in describe.getElementsByTagNameNS( "http://www.w3.org/2001/XMLSchema", "complexType"): featurestype[type_element.getAttribute( "name")] = type_element except ExpatError as e: print( colorize( "ERROR! an error occurred while trying to " "parse the DescribeFeatureType document.", RED)) print(colorize(str(e), RED)) print("URL: {}\nxml:\n{}".format(wfs_descrfeat_url, content)) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [] else: raise except AttributeError: print( colorize( "ERROR! an error occurred while trying to " "read the Mapfile and recover the themes.", RED)) print("URL: {}\nxml:\n{}".format(wfs_descrfeat_url, content)) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [] else: raise else: featurestype = self.featuretype_cache[url] if featurestype is None: return [] layers = [layer] if wmscap is not None and layer in list(wmscap.contents): layer_obj = wmscap[layer] if len(layer_obj.layers) > 0: layers = [l.name for l in layer_obj.layers] attributes = [] for sub_layer in layers: # Should probably be adapted for other king of servers type_element = featurestype.get("{}Type".format(sub_layer)) if type_element is not None: for element in type_element.getElementsByTagNameNS( "http://www.w3.org/2001/XMLSchema", "element"): if not element.getAttribute("type").startswith("gml:"): attributes.append(element.getAttribute("name")) return attributes
def get_report(self): self.layername = self.request.matchdict["layername"] layer_config = self.config["layers"].get(self.layername) multiple = layer_config.get("multiple", False) ids = self.request.matchdict["ids"] if multiple: ids = ids.split(",") if layer_config is None: raise HTTPBadRequest("Layer not found") features_ids = [self.layername + "." + id_ for id_ in ids] if multiple \ else [self.layername + "." + ids] if layer_config["check_credentials"]: # check user credentials role_id = None if self.request.user is None else self.request.user.role.id # FIXME: support of mapserver groups ogc_server_ids = [self.default_ogc_server.id] private_layers_object = get_private_layers(ogc_server_ids) private_layers_names = [private_layers_object[oid].name for oid in private_layers_object] protected_layers_object = get_protected_layers(role_id, ogc_server_ids) protected_layers_names = [protected_layers_object[oid].name for oid in protected_layers_object] if self.layername in private_layers_names and self.layername not in protected_layers_names: raise HTTPForbidden srs = layer_config["srs"] mapserv_url = self.request.route_url("mapserverproxy") vector_request_url = add_url_params( mapserv_url, { "service": "WFS", "version": "1.1.0", "outputformat": "gml3", "request": "GetFeature", "typeName": self.layername, "featureid": ",".join(features_ids), "srsName": "epsg:{}".format(srs) } ) spec = layer_config["spec"] if spec is None: spec = { "layout": self.layername, "outputFormat": "pdf", "attributes": { "ids": [{ "id": id_ } for id_ in ids] } if multiple else { "id": id } } map_config = layer_config.get("map") if map_config is not None: spec["attributes"]["map"] = self._build_map( mapserv_url, vector_request_url, srs, map_config ) maps_config = layer_config.get("maps") if maps_config is not None: spec["attributes"]["maps"] = [] for map_config in maps_config: spec["attributes"]["maps"].append(self._build_map( mapserv_url, vector_request_url, srs, map_config )) else: datasource = layer_config.get("datasource", True) if multiple and datasource: data = dumps(layer_config["data"]) datas = [ loads(data % { "layername": self.layername, "id": id_, "srs": srs, "mapserv_url": mapserv_url, "vector_request_url": vector_request_url, }) for id_ in ids] self.walker(spec, "%(datasource)s", datas) spec = loads(dumps(spec) % { "layername": self.layername, "srs": srs, "mapserv_url": mapserv_url, "vector_request_url": vector_request_url, }) elif multiple: spec = loads(dumps(spec) % { "layername": self.layername, "ids": ",".join(ids), "srs": srs, "mapserv_url": mapserv_url, "vector_request_url": vector_request_url, }) else: spec = loads(dumps(spec) % { "layername": self.layername, "id": ids, "srs": srs, "mapserv_url": mapserv_url, "vector_request_url": vector_request_url, }) return self._do_print(spec)
def _layer_attributes(self, url, layer): errors = set() request = _Request() request.registry.settings = self.config # static schema will not be supported url = get_url2("Layer", url, request, errors) if len(errors) > 0: print("\n".join(errors)) return [] wms_getcap_url = add_url_params(url, { "SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetCapabilities", }) hostname = urlsplit(url).hostname if url not in self.wmscap_cache: print("Get WMS GetCapabilities for URL: {}".format(url)) self.wmscap_cache[url] = None # forward request to target (without Host Header) http = httplib2.Http() h = {} if hostname == "localhost": # pragma: no cover h["Host"] = self.package["host"] try: resp, content = http.request(wms_getcap_url, method="GET", headers=h) try: self.wmscap_cache[url] = WebMapService(None, xml=content) except Exception as e: print(colorize( "ERROR! an error occurred while trying to " "parse the GetCapabilities document.", RED)) print(colorize(str(e), RED)) print("URL: {}\nxml:\n{}".format(wms_getcap_url, content)) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") != "TRUE": raise except Exception as e: # pragma: no cover print(colorize(str(e), RED)) print(colorize( "ERROR! Unable to GetCapabilities from URL: {}".format(wms_getcap_url), RED, )) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") != "TRUE": raise wmscap = self.wmscap_cache[url] wfs_descrfeat_url = add_url_params(url, { "SERVICE": "WFS", "VERSION": "1.1.0", "REQUEST": "DescribeFeatureType", }) if url not in self.featuretype_cache: print("Get WFS DescribeFeatureType for URL: {}".format(wfs_descrfeat_url)) self.featuretype_cache[url] = None # forward request to target (without Host Header) http = httplib2.Http() h = {} if hostname == "localhost": # pragma: no cover h["Host"] = self.package["host"] try: resp, content = http.request(wfs_descrfeat_url, method="GET", headers=h) except Exception as e: # pragma: no cover print(colorize(str(e), RED)) print(colorize( "ERROR! Unable to DescribeFeatureType from URL: {}".format(wfs_descrfeat_url), RED, )) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [] else: raise if resp.status < 200 or resp.status >= 300: # pragma: no cover print(colorize( "ERROR! DescribeFeatureType from URL {} return the error: {1:d} {}".format( wfs_descrfeat_url, resp.status, resp.reason ), RED, )) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [] else: raise Exception("Aborted") try: describe = parseString(content) featurestype = {} self.featuretype_cache[url] = featurestype for type_element in describe.getElementsByTagNameNS( "http://www.w3.org/2001/XMLSchema", "complexType" ): featurestype[type_element.getAttribute("name")] = type_element except ExpatError as e: print(colorize( "ERROR! an error occurred while trying to " "parse the DescribeFeatureType document.", RED )) print(colorize(str(e), RED)) print("URL: {}\nxml:\n{}".format(wfs_descrfeat_url, content)) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [] else: raise except AttributeError: print(colorize( "ERROR! an error occurred while trying to " "read the Mapfile and recover the themes.", RED )) print("URL: {}\nxml:\n{}".format(wfs_descrfeat_url, content)) if os.environ.get("IGNORE_I18N_ERRORS", "FALSE") == "TRUE": return [] else: raise else: featurestype = self.featuretype_cache[url] if featurestype is None: return [] layers = [layer] if wmscap is not None and layer in list(wmscap.contents): layer_obj = wmscap[layer] if len(layer_obj.layers) > 0: layers = [l.name for l in layer_obj.layers] attributes = [] for sub_layer in layers: # Should probably be adapted for other king of servers type_element = featurestype.get("{}Type".format(sub_layer)) if type_element is not None: for element in type_element.getElementsByTagNameNS( "http://www.w3.org/2001/XMLSchema", "element" ): if not element.getAttribute("type").startswith("gml:"): attributes.append(element.getAttribute("name")) return attributes, layers
async def _wms_getcap_cached(self, ogc_server, _): """ _ is just for cache on the role id """ errors: Set[str] = set() url = get_url2("The OGC server '{}'".format(ogc_server.name), ogc_server.url, self.request, errors) if errors or url is None: # pragma: no cover return url, None, errors # Add functionality params sparams = get_mapserver_substitution_params(self.request) url = add_url_params(url, sparams) url = add_url_params( url, { "SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetCapabilities", "ROLE_ID": "0", "USER_ID": "0", }, ) LOG.debug("Get WMS GetCapabilities for url: %s", url) # Forward request to target (without Host Header) headers = dict(self.request.headers) # Add headers for Geoserver if ogc_server.auth == main.OGCSERVER_AUTH_GEOSERVER: headers["sec-username"] = "******" headers["sec-roles"] = "root" if urllib.parse.urlsplit( url ).hostname != "localhost" and "Host" in headers: # pragma: no cover headers.pop("Host") try: response = await asyncio.get_event_loop().run_in_executor( None, get_http_cached, self.http_options, url, headers) except Exception: # pragma: no cover error = "Unable to GetCapabilities from URL {}".format(url) errors.add(error) LOG.error(error, exc_info=True) return url, None, errors if not response.ok: # pragma: no cover error = "GetCapabilities from URL {} return the error: {:d} {}".format( url, response.status_code, response.reason) errors.add(error) LOG.error(error) return url, None, errors # With wms 1.3 it returns text/xml also in case of error :-( if response.headers.get("Content-Type", "").split(";")[0].strip() not in [ "application/vnd.ogc.wms_xml", "text/xml", ]: error = "GetCapabilities from URL {} returns a wrong Content-Type: {}\n{}".format( url, response.headers.get("Content-Type", ""), response.text) errors.add(error) LOG.error(error) return url, None, errors return url, response.content, errors
def get_report(self): self.layername = self.request.matchdict["layername"] layer_config = self.config["layers"].get(self.layername) multiple = layer_config.get("multiple", False) ids = self.request.matchdict["ids"] if multiple: ids = ids.split(",") if layer_config is None: raise HTTPBadRequest("Layer not found") features_ids = [self.layername + "." + id_ for id_ in ids] if multiple \ else [self.layername + "." + ids] if layer_config["check_credentials"]: # check user credentials role_id = None if self.request.user is None else self.request.user.role.id # FIXME: support of mapserver groups ogc_server_ids = [self.default_ogc_server.id] private_layers_object = get_private_layers(ogc_server_ids) private_layers_names = [ private_layers_object[oid].name for oid in private_layers_object ] protected_layers_object = get_protected_layers( role_id, ogc_server_ids) protected_layers_names = [ protected_layers_object[oid].name for oid in protected_layers_object ] if self.layername in private_layers_names and self.layername not in protected_layers_names: raise HTTPForbidden srs = layer_config["srs"] mapserv_url = self.request.route_url("mapserverproxy") vector_request_url = add_url_params( mapserv_url, { "service": "WFS", "version": "1.1.0", "outputformat": "gml3", "request": "GetFeature", "typeName": self.layername, "featureid": ",".join(features_ids), "srsName": "epsg:{}".format(srs) }) spec = layer_config["spec"] if spec is None: spec = { "layout": self.layername, "outputFormat": "pdf", "attributes": { "ids": [{ "id": id_ } for id_ in ids] } if multiple else { "id": id } } map_config = layer_config.get("map") if map_config is not None: spec["attributes"]["map"] = self._build_map( mapserv_url, vector_request_url, srs, map_config) maps_config = layer_config.get("maps") if maps_config is not None: spec["attributes"]["maps"] = [] for map_config in maps_config: spec["attributes"]["maps"].append( self._build_map(mapserv_url, vector_request_url, srs, map_config)) else: datasource = layer_config.get("datasource", True) if multiple and datasource: data = dumps(layer_config["data"]) datas = [ loads( data % { "layername": self.layername, "id": id_, "srs": srs, "mapserv_url": mapserv_url, "vector_request_url": vector_request_url, }) for id_ in ids ] self.walker(spec, "%(datasource)s", datas) spec = loads( dumps(spec) % { "layername": self.layername, "srs": srs, "mapserv_url": mapserv_url, "vector_request_url": vector_request_url, }) elif multiple: spec = loads( dumps(spec) % { "layername": self.layername, "ids": ",".join(ids), "srs": srs, "mapserv_url": mapserv_url, "vector_request_url": vector_request_url, }) else: spec = loads( dumps(spec) % { "layername": self.layername, "id": ids, "srs": srs, "mapserv_url": mapserv_url, "vector_request_url": vector_request_url, }) return self._do_print(spec)