def test_add_url_params(self): from c2cgeoportal.lib import add_url_params params = {"Name": "Bob", "Age": 18, "Nationality": u"Việt Nam"} result = add_url_params("http://test/", params) self.assertEqual( result, "http://test/?Nationality=Vi%E1%BB%87t+Nam&Age=18&Name=Bob")
def wfscapabilities(self): _url = add_url_params(self.request.route_url("mapserverproxy"), { "SERVICE": "WFS", "VERSION": "1.1.0", "REQUEST": "GetCapabilities", }) return self.make_response(self.testurl(_url))
def themes_errors(self): from c2cgeoportal.models import DBSession, Interface settings = self.settings.get("themes", {}) url = self.request.route_url("themes") h = Http() default_params = settings.get("default", {}).get("params", {}) results = [] for interface, in DBSession.query(Interface.name).all(): params = {} params.update(default_params) params.update(settings.get(interface, {}).get("params", {})) params["interface"] = interface interface_url = add_url_params(url, params) interface_url, headers = build_url("Check the theme", interface_url, self.request) resp, content = h.request(interface_url, headers=headers) if resp.status != httplib.OK: self.set_status(resp.status, resp.reason) results.append("{}: {}".format(interface, content)) result = loads(content) if len(result["errors"]) != 0: self.set_status(500, "Theme with error") results.append("{}: Theme with error\n{}".format( Interface.name, "\n".join(result["errors"]))) return self.make_response("OK" if len(results) == 0 else urllib.unquote("\n\n".join(results)))
def themes_errors(self): from c2cgeoportal.models import DBSession, Interface settings = self.settings.get("themes", {}) url = self.request.route_url("themes") h = Http() default_params = settings.get("default", {}).get("params", {}) for (interface,) in DBSession.query(Interface.name).all(): params = {} params.update(default_params) params.update(settings.get(interface, {}).get("params", {})) params["interface"] = interface interface_url = add_url_params(url, params) interface_url, headers = build_url("Check the theme", interface_url, self.request) resp, content = h.request(interface_url, headers=headers) if resp.status != httplib.OK: self.set_status(resp.status, resp.reason) return self.make_response(content) result = loads(content) if len(result["errors"]) != 0: self.set_status(500, "Theme with error") return self.make_response( "Theme with error for interface '%s'\n%s" % (Interface.name, "\n".join(result["errors"])) ) return self.make_response("OK")
def routes(self): named_urls = [( route["name"], add_url_params( self.request.route_url(route["name"]), route.get("params", {}), ), ) for route in self.settings["routes"] if route["name"] not in self.settings["routes_disable"]] return self.testurls(named_urls)
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: # 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 _layer_attributes(self, url, layer): url = add_url_params(url, { "SERVICE": "WFS", "VERSION": "1.1.0", "REQUEST": "DescribeFeatureType", }) if url not in self.featuretype_cache: print("Get DescribeFeatureType for url: %s" % url) self.featuretype_cache[url] = None # forward request to target (without Host Header) http = httplib2.Http() h = {} if urlsplit(url).hostname == "localhost": # pragma: no cover h["Host"] = self.package["host"] try: resp, content = http.request(url, method="GET", headers=h) except: # pragma: no cover print("Unable to DescribeFeatureType from url %s" % url) self.capabilities_cache[url] = None return [] if resp.status < 200 or resp.status >= 300: # pragma: no cover print( "DescribeFeatureType from url %s return the error: %i %s" % (url, resp.status, resp.reason) ) self.capabilities_cache[url] = None return [] try: describe = parseString(content) self.featuretype_cache[url] = describe except AttributeError: print( "WARNING! an error occured while trying to " "read the mapfile and recover the themes." ) print("url: %s\nxml:\n%s" % (url, content)) else: describe = self.featuretype_cache[url] if describe is None: return [] attributes = [] # Should probably be adapted for other king of servers for type_element in describe.getElementsByTagName("complexType"): if type_element.getAttribute("name") == "%sType" % layer: for element in type_element.getElementsByTagName("element"): if not element.getAttribute("type").startswith("gml:"): attributes.append(element.getAttribute("name")) return attributes
def _fill_legend_rule_query_string(self, l, layer, url): if layer.legend_rule and url: l["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 _pdf(self): body = { "comment": "Foobar", "title": "Bouchon", "units": "m", "srs": "EPSG:%i" % self.request.registry.settings["srid"], "dpi": 254, "layers": [], "layout": self.settings["print_template"], "pages": [{ "center": [self.settings["print_center_lon"], self.settings["print_center_lat"]], "col0": "", "rotation": 0, "scale": self.settings["print_scale"], "table": { "columns": ["col0"], "data": [{ "col0": "" }] } }] } body = dumps(body) _url = add_url_params(self.request.route_url("printproxy_create"), { "url": self.request.route_url("printproxy"), }) h = Http() log.info("Checker for printproxy request (create): %s" % _url) _url = _url.replace(self.request.environ.get("SERVER_NAME"), "localhost") headers = { "Content-Type": "application/json;charset=utf-8", "Host": self.request.environ.get("HTTP_HOST") } resp, content = h.request(_url, "POST", headers=headers, body=body) if resp.status != httplib.OK: self.set_status(resp.status, resp.reason) return "Failed creating PDF: " + content log.info("Checker for printproxy pdf (retrieve): %s" % _url) json = loads(content) _url = json["getURL"].replace(self.request.environ.get("SERVER_NAME"), "localhost") headers = {"Host": self.request.environ.get("HTTP_HOST")} resp, content = h.request(_url, headers=headers) if resp.status != httplib.OK: self.set_status(resp.status, resp.reason) return "Failed retrieving PDF: " + content return "OK"
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 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 routes(self): named_urls = [ ( route["name"], add_url_params( self.request.route_url(route["name"]), route.get("params", {}), ), ) for route in self.settings["routes"] if route["name"] not in self.settings["routes_disable"] ] return self.testurls(named_urls)
def _fill_wms(self, l, layer, version=1): l["imageType"] = layer.image_type if version == 1 and layer.legend_rule: l["icon"] = add_url_params(self.request.route_url("mapserverproxy"), { "SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetLegendGraphic", "LAYER": layer.name, "FORMAT": "image/png", "TRANSPARENT": "TRUE", "RULE": layer.legend_rule, }) if layer.style: l["style"] = layer.style
def _pdf(self): body = { "comment": "Foobar", "title": "Bouchon", "units": "m", "srs": "EPSG:%i" % self.request.registry.settings["srid"], "dpi": 254, "layers": [], "layout": self.settings["print_template"], "pages": [{ "center": [self.settings["print_center_lon"], self.settings["print_center_lat"]], "col0": "", "rotation": 0, "scale": self.settings["print_scale"], "table": { "columns": ["col0"], "data": [{ "col0": "" }] } }] } body = dumps(body) url = add_url_params(self.request.route_url("printproxy_create"), { "url": self.request.route_url("printproxy"), }) url, headers = build_url("Check the printproxy request (create)", url, self.request, { "Content-Type": "application/json;charset=utf-8", }) h = Http() resp, content = h.request(url, "POST", headers=headers, body=body) if resp.status != httplib.OK: self.set_status(resp.status, resp.reason) return "Failed creating PDF: " + content json = loads(content) url, headers = build_url( "Check the printproxy pdf (retrieve)", json["getURL"], self.request ) resp, content = h.request(url, headers=headers) if resp.status != httplib.OK: self.set_status(resp.status, resp.reason) return "Failed retrieving PDF: " + content return "OK"
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 test_add_url_params(self): from c2cgeoportal.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 _layer_attributes(self, url, layer): url = add_url_params(url, { "SERVICE": "WFS", "VERSION": "1.1.0", "REQUEST": "DescribeFeatureType", "FEATURES": layer, }) print("Get DescribeFeatureType for url: %s" % url) # forward request to target (without Host Header) http = httplib2.Http() h = {} if urlsplit(url).hostname == "localhost": # pragma: no cover h["Host"] = self.package["host"] try: resp, content = http.request(url, method="GET", headers=h) except: # pragma: no cover print("Unable to DescribeFeatureType from url %s" % url) self.capabilities_cache[url] = None return [] if resp.status < 200 or resp.status >= 300: # pragma: no cover print( "DescribeFeatureType from url %s return the error: %i %s" % (url, resp.status, resp.reason) ) self.capabilities_cache[url] = None return [] try: describe = parseString(content) except AttributeError: print( "WARNING! an error occured while trying to " "read the mapfile and recover the themes." ) print("url: %s\nxml:\n%s" % (url, content)) attributes = [] for element in describe.getElementsByTagName("element"): if element.getAttribute("type") not in [ "gml:PointPropertyType", "gml:LineStringPropertyType", "gml:PolygonPropertyType" ]: attributes.append(element.getAttribute("name")) return attributes
def _layer_attributes(self, url, layer): url = add_url_params( url, { "SERVICE": "WFS", "VERSION": "1.1.0", "REQUEST": "DescribeFeatureType", "TYPENAME": layer, }) print("Get DescribeFeatureType for url: %s" % url) # forward request to target (without Host Header) http = httplib2.Http() h = dict(self.request.headers) if urlsplit(url).hostname != "localhost": # pragma: no cover h.pop("Host") try: resp, content = http.request(url, method="GET", headers=h) except: # pragma: no cover print("Unable to DescribeFeatureType from url %s" % url) self.capabilities_cache[url] = None return [] if resp.status < 200 or resp.status >= 300: # pragma: no cover print("DescribeFeatureType from url %s return the error: %i %s" % (url, resp.status, resp.reason)) self.capabilities_cache[url] = None return [] try: describe = parseString(content) except AttributeError: print("WARNING! an error occured while trying to " "read the mapfile and recover the themes.") print("url: %s\nxml:\n%s" % (url, content)) attributes = [] for element in describe.getElementsByTagName("element"): if element.getAttribute("type") not in [ "gml:PointPropertyType", "gml:LineStringPropertyType", "gml:PolygonPropertyType" ]: attributes.append(element.getAttribute("name"))
def _fts(self): url = add_url_params( self.request.route_url("fulltextsearch"), {"query": self.settings["fulltextsearch"], "limit": "1"} ) url, headers = build_url("Check the fulltextsearch", url, self.request) h = Http() resp, content = h.request(url, headers=headers) if resp.status != httplib.OK: self.set_status(resp.status, resp.reason) return content result = loads(content) if len(result["features"]) == 0: self.set_status(httplib.BAD_REQUEST, httplib.responses[httplib.BAD_REQUEST]) return "No result" return "OK"
def _wms_getcap_cached(self, url): errors = set() wms = None url = add_url_params(url, { "SERVICE": "WMS", "VERSION": "1.1.1", "REQUEST": "GetCapabilities", }) log.info("Get WMS GetCapabilities for url: %s" % url) # forward request to target (without Host Header) http = httplib2.Http() h = dict(self.request.headers) if urlsplit(url).hostname != "localhost": # pragma: no cover h.pop("Host") try: resp, content = http.request(url, method="GET", headers=h) except: # pragma: no cover errors.add("Unable to GetCapabilities from url %s" % url) return None, errors if resp.status < 200 or resp.status >= 300: # pragma: no cover errors.add( "GetCapabilities from url %s return the error: %i %s" % (url, resp.status, resp.reason) ) return None, errors try: wms = WebMapService(None, xml=content) except AttributeError: error = _( "WARNING! an error occured while trying to " "read the mapfile and recover the themes." ) error = "%s\nurl: %s\nxml:\n%s" % (error, url, content) errors.add(error) log.exception(error) return wms, errors
def _fts(self): url = add_url_params(self.request.route_url("fulltextsearch"), { "query": self.settings["fulltextsearch"], "limit": "1", }) url, headers = build_url("Check the fulltextsearch", url, self.request) h = Http() resp, content = h.request(url, headers=headers) if resp.status != httplib.OK: self.set_status(resp.status, resp.reason) return content result = loads(content) if len(result["features"]) == 0: self.set_status(httplib.BAD_REQUEST, httplib.responses[httplib.BAD_REQUEST]) return "No result" return "OK"
def themes_errors(self): from c2cgeoportal.models import DBSession, Interface settings = self.settings.get("themes", {}) _url = self.request.route_url("themes") h = Http() default_params = settings.get("default", {}).get("params", {}) for interface, in DBSession.query(Interface.name).all(): params = {} params.update(default_params) params.update(settings.get(interface, {}).get("params", {})) params["interface"] = interface interface_url = add_url_params(_url, params) log.info("Checker for theme: %s" % interface_url) interface_url = interface_url.replace( self.request.environ.get("SERVER_NAME"), "localhost" ) headers = {"host": self.request.environ.get("HTTP_HOST")} resp, content = h.request(interface_url, headers=headers) if resp.status != httplib.OK: self.set_status(resp.status, resp.reason) return self.make_response(content) result = loads(content) if len(result["errors"]) != 0: self.set_status(500, "Theme with error") return self.make_response("Theme with error for interface '%s'\n%s" % ( Interface.name, "\n".join(result["errors"]) )) return self.make_response("OK")
def _fts(self): _url = add_url_params(self.request.route_url("fulltextsearch"), { "query": self.settings["fulltextsearch"], "limit": "1", }) h = Http() log.info("Checker for fulltextsearch: %s" % _url) _url = _url.replace(self.request.environ.get("SERVER_NAME"), "localhost") headers = {"host": self.request.environ.get("HTTP_HOST")} resp, content = h.request(_url, headers=headers) if resp.status != httplib.OK: self.set_status(resp.status, resp.reason) return content result = loads(content) if len(result["features"]) == 0: self.set_status(httplib.BAD_REQUEST, httplib.responses[httplib.BAD_REQUEST]) return "No result" return "OK"
def test_add_url_params_noparam(self): self.assertEqual(add_url_params( "http://example.com/", {} ), "http://example.com/")
def test_add_url_params(self): from c2cgeoportal.lib import add_url_params params = {"Name": "Bob", "Age": 18, "Nationality": u"Việt Nam"} result = add_url_params("http://test/", params) self.assertEqual(result, "http://test/?Nationality=Vi%E1%BB%87t+Nam&Age=18&Name=Bob")
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 _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 [] url = add_url_params(url, { "SERVICE": "WFS", "VERSION": "1.1.0", "REQUEST": "DescribeFeatureType", }) if url not in self.featuretype_cache: print("Get DescribeFeatureType for url: %s" % url) self.featuretype_cache[url] = None # forward request to target (without Host Header) http = httplib2.Http() h = {} if urlsplit(url).hostname == "localhost": # pragma: no cover h["Host"] = self.package["host"] try: resp, content = http.request(url, method="GET", headers=h) except: # pragma: no cover print("Unable to DescribeFeatureType from URL %s" % url) self.featuretype_cache[url] = None return [] if resp.status < 200 or resp.status >= 300: # pragma: no cover print( "DescribeFeatureType from URL %s return the error: %i %s" % (url, resp.status, resp.reason) ) self.featuretype_cache[url] = None return [] try: describe = parseString(content) self.featuretype_cache[url] = describe except AttributeError: print( "WARNING! an error occured while trying to " "read the Mapfile and recover the themes." ) print("URL: %s\nxml:\n%s" % (url, content)) else: describe = self.featuretype_cache[url] if describe is None: return [] attributes = [] # Should probably be adapted for other king of servers for type_element in describe.getElementsByTagNameNS( "http://www.w3.org/2001/XMLSchema", "complexType" ): if type_element.getAttribute("name") == "%sType" % layer: 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 _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 [] url = add_url_params( url, { "SERVICE": "WFS", "VERSION": "1.1.0", "REQUEST": "DescribeFeatureType", }) if url not in self.featuretype_cache: print("Get DescribeFeatureType for url: %s" % url) self.featuretype_cache[url] = None # forward request to target (without Host Header) http = httplib2.Http() h = {} if urlsplit(url).hostname == "localhost": # pragma: no cover h["Host"] = self.package["host"] try: resp, content = http.request(url, method="GET", headers=h) except: # pragma: no cover print("Unable to DescribeFeatureType from URL %s" % url) self.featuretype_cache[url] = None return [] if resp.status < 200 or resp.status >= 300: # pragma: no cover print( "DescribeFeatureType from URL %s return the error: %i %s" % (url, resp.status, resp.reason)) self.featuretype_cache[url] = None return [] try: describe = parseString(content) self.featuretype_cache[url] = describe except AttributeError: print("WARNING! an error occured while trying to " "read the Mapfile and recover the themes.") print("URL: %s\nxml:\n%s" % (url, content)) else: describe = self.featuretype_cache[url] if describe is None: return [] attributes = [] # Should probably be adapted for other king of servers for type_element in describe.getElementsByTagNameNS( "http://www.w3.org/2001/XMLSchema", "complexType"): if type_element.getAttribute("name") == "%sType" % layer: 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