class Layer(ResourceInfo): def __init__(self, catalog, name): super(Layer, self).__init__() self.catalog = catalog self.name = name resource_type = "layer" save_method = "PUT" @property def href(self): return url(self.catalog.service_url, ["layers", self.name + ".xml"]) @property def resource(self): if self.dom is None: self.fetch() name = self.dom.find("resource/name").text return self.catalog.get_resource(name) def _get_default_style(self): if 'default_style' in self.dirty: return self.dirty['default_style'] if self.dom is None: self.fetch() element = self.dom.find("defaultStyle") # aborted data uploads can result in no default style return self._resolve_style(element) if element is not None else None def _resolve_style(self, element): name_section = element.find('name') if name_section is not None: return self.catalog.get_style(name_section.text) else: return None def _set_default_style(self, style): if isinstance(style, Style): style = style.fqn self.dirty["default_style"] = style def _get_alternate_styles(self): if "alternate_styles" in self.dirty: return self.dirty["alternate_styles"] if self.dom is None: self.fetch() styles_list = self.dom.findall("styles/style") return [ _f for _f in [self._resolve_style(s) for s in styles_list] if _f ] def _set_alternate_styles(self, styles): self.dirty["alternate_styles"] = styles default_style = property(_get_default_style, _set_default_style) styles = property(_get_alternate_styles, _set_alternate_styles) attribution_object = xml_property("attribution", _read_attribution) enabled = xml_property("enabled", lambda x: x.text == "true") advertised = xml_property("advertised", lambda x: x.text == "true", default=True) def _get_attr_attribution(self): return { 'title': self.attribution_object.title, 'width': self.attribution_object.width, 'height': self.attribution_object.height, 'href': self.attribution_object.href, 'url': self.attribution_object.url, 'type': self.attribution_object.type } def _set_attr_attribution(self, attribution): self.dirty["attribution"] = _attribution( attribution['title'], attribution['width'], attribution['height'], attribution['href'], attribution['url'], attribution['type']) assert self.attribution_object.title == attribution['title'] assert self.attribution_object.width == attribution['width'] assert self.attribution_object.height == attribution['height'] assert self.attribution_object.href == attribution['href'] assert self.attribution_object.url == attribution['url'] assert self.attribution_object.type == attribution['type'] attribution = property(_get_attr_attribution, _set_attr_attribution) writers = dict(attribution=_write_attribution, enabled=write_bool("enabled"), advertised=write_bool("advertised"), default_style=_write_default_style, alternate_styles=_write_alternate_styles)
class Coverage(_ResourceBase): resource_type = "coverage" url_part_stores = 'coveragestores' url_part_types = 'coverages' title = xml_property("title") abstract = xml_property("abstract") enabled = xml_property("enabled") advertised = xml_property("advertised", default="true") native_bbox = xml_property("nativeBoundingBox", bbox) latlon_bbox = xml_property("latLonBoundingBox", bbox) projection = xml_property("srs") projection_policy = xml_property("projectionPolicy") keywords = xml_property("keywords", string_list) request_srs_list = xml_property("requestSRS", string_list) response_srs_list = xml_property("responseSRS", string_list) supported_formats = xml_property("supportedFormats", string_list) metadata_links = xml_property("metadataLinks", metadata_link_list) metadata = xml_property("metadata", metadata) writers = dict( title = write_string("title"), abstract = write_string("abstract"), enabled = write_bool("enabled"), advertised = write_bool("advertised"), nativeBoundingBox = write_bbox("nativeBoundingBox"), latLonBoundingBox = write_bbox("latLonBoundingBox"), srs = write_string("srs"), projection_policy = write_string("projectionPolicy"), keywords = write_string_list("keywords"), metadataLinks = write_metadata_link_list("metadataLinks"), requestSRS = write_string_list("requestSRS"), responseSRS = write_string_list("responseSRS"), supportedFormats = write_string_list("supportedFormats"), metadata = write_metadata("metadata") )
class FeatureType(_ResourceBase): resource_type = "featureType" url_part_stores = 'datastores' url_part_types = 'featuretypes' title = xml_property("title") abstract = xml_property("abstract") enabled = xml_property("enabled") advertised = xml_property("advertised", default="true") native_bbox = xml_property("nativeBoundingBox", bbox) latlon_bbox = xml_property("latLonBoundingBox", bbox) projection = xml_property("srs") projection_policy = xml_property("projectionPolicy") keywords = xml_property("keywords", string_list) attributes = xml_property("attributes", attribute_list) metadata_links = xml_property("metadataLinks", metadata_link_list) metadata = xml_property("metadata", metadata) writers = dict( name = write_string("name"), title = write_string("title"), abstract = write_string("abstract"), enabled = write_bool("enabled"), advertised = write_bool("advertised"), nativeBoundingBox = write_bbox("nativeBoundingBox"), latLonBoundingBox = write_bbox("latLonBoundingBox"), srs = write_string("srs"), nativeCRS = write_string("nativeCRS"), projectionPolicy = write_string("projectionPolicy"), keywords = write_string_list("keywords"), metadataLinks = write_metadata_link_list("metadataLinks"), metadata = write_metadata("metadata") )
class FeatureType(_ResourceBase): resource_type = "featureType" url_part_stores = 'datastores' url_part_types = 'featuretypes' title = xml_property("title") native_name = xml_property("nativeName") abstract = xml_property("abstract") enabled = xml_property("enabled") advertised = xml_property("advertised", default="true") native_bbox = xml_property("nativeBoundingBox", bbox) latlon_bbox = xml_property("latLonBoundingBox", bbox) projection = xml_property("srs") projection_policy = xml_property("projectionPolicy") keywords = xml_property("keywords", string_list) attributes = xml_property("attributes", attribute_list) metadata_links = xml_property("metadataLinks", metadata_link_list) metadata = xml_property("metadata", metadata) cqlFilter = xml_property("cqlFilter") writers = { 'name': write_string("name"), 'nativeName': write_string("nativeName"), 'title': write_string("title"), 'abstract': write_string("abstract"), 'enabled': write_bool("enabled"), 'advertised': write_bool("advertised"), 'nativeBoundingBox': write_bbox("nativeBoundingBox"), 'latLonBoundingBox': write_bbox("latLonBoundingBox"), 'srs': write_string("srs"), 'nativeCRS': write_string("nativeCRS"), 'projectionPolicy': write_string("projectionPolicy"), 'keywords': write_string_list("keywords"), 'metadataLinks': write_metadata_link_list("metadataLinks"), 'metadata': write_metadata("metadata"), 'cqlFilter': write_string('cqlFilter') }
class WmsLayer(ResourceInfo): resource_type = "wmsLayer" save_method = settings.PUT def __init__(self, catalog, workspace, store, name): super(WmsLayer, self).__init__() self.catalog = catalog self.workspace = workspace self.store = store self.name = name @property def href(self): return urljoin( self.catalog.service_url, "workspaces/{}/wmsstores/{}/wmslayers/{}.xml".format( self.workspace.name, self.store.name, self.name)) title = xml_property("title") description = xml_property("description") abstract = xml_property("abstract") keywords = xml_property("keywords", string_list) # nativeCRS projection = xml_property("srs") native_bbox = xml_property("nativeBoundingBox", bbox) latlon_bbox = xml_property("latLonBoundingBox", bbox) projection_policy = xml_property("projectionPolicy") enabled = xml_property("enabled", lambda x: x.text == "true") advertised = xml_property("advertised", lambda x: x.text == "true", default=True) metadata_links = xml_property("metadataLinks", metadata_link_list) writers = { 'title': write_string("title"), 'description': write_string("description"), 'abstract': write_string("abstract"), 'keywords': write_string_list("keywords"), # nativeCRS 'srs': write_string("srs"), 'nativeBoundingBox': write_bbox("nativeBoundingBox"), 'latLonBoundingBox': write_bbox("latLonBoundingBox"), 'projectionPolicy': write_string("projectionPolicy"), 'enabled': write_bool("enabled"), 'advertised': write_bool("advertised"), 'metadataLinks': write_metadata_link_list("metadataLinks") }
class Coverage(_ResourceBase): resource_type = "coverage" url_part_stores = 'coveragestores' url_part_types = 'coverages' title = xml_property("title") native_name = xml_property("nativeName") native_format = xml_property("nativeFormat") native_crs = xml_property("nativeCRS") default_interpolation_method = xml_property("defaultInterpolationMethod") abstract = xml_property("abstract") description = xml_property("description") enabled = xml_property("enabled") advertised = xml_property("advertised", default="true") native_bbox = xml_property("nativeBoundingBox", bbox) latlon_bbox = xml_property("latLonBoundingBox", bbox) projection = xml_property("srs") projection_policy = xml_property("projectionPolicy") keywords = xml_property("keywords", string_list) request_srs_list = xml_property("requestSRS", string_list) response_srs_list = xml_property("responseSRS", string_list) supported_formats = xml_property("supportedFormats", string_list) metadata_links = xml_property("metadataLinks", metadata_link_list) metadata = xml_property("metadata", metadata) interpolation_methods = xml_property("interpolationMethods", string_list) writers = { 'title': write_string("title"), 'native_name': write_string("nativeName"), 'native_format': write_string("nativeFormat"), 'native_crs': write_string("nativeCRS"), 'default_interpolation_method': write_string("defaultInterpolationMethod"), 'description': write_string("description"), 'abstract': write_string("abstract"), 'enabled': write_bool("enabled"), 'advertised': write_bool("advertised"), 'nativeBoundingBox': write_bbox("nativeBoundingBox"), 'latLonBoundingBox': write_bbox("latLonBoundingBox"), 'srs': write_string("srs"), 'projection_policy': write_string("projectionPolicy"), 'keywords': write_string_list("keywords"), 'metadataLinks': write_metadata_link_list("metadataLinks"), 'requestSRS': write_string_list("requestSRS"), 'responseSRS': write_string_list("responseSRS"), 'supportedFormats': write_string_list("supportedFormats"), 'interpolation_methods': write_string_list("interpolationMethods"), 'metadata': write_metadata("metadata") }
class LayerGroup(ResourceInfo): """ Represents a layer group in geoserver """ resource_type = "layerGroup" save_method = settings.PUT def __init__(self, catalog, name, workspace=None): super(LayerGroup, self).__init__() assert isinstance(name, str) self.catalog = catalog self.name = name self.workspace = workspace # the XML format changed in 2.3.x - the element listing all the layers # and the entries themselves have changed if self.catalog.gsversion() == "2.2.x": parent, element, attributes = "layers", "layer", None else: parent = "publishables" element = "published" attributes = {'type': 'layer'} self._layer_parent = parent self._layer_element = element self._layer_attributes = attributes self.writers = { 'name': write_string("name"), 'styles': _write_styles, 'layers': lambda b, l: _write_layers(b, l, parent, element, attributes), 'bounds': write_bbox("bounds"), 'workspace': write_string("workspace"), 'abstractTxt': write_string("abstractTxt"), 'title': write_string("title") } @property def href(self): path_parts = "layergroups/{}.xml".format(self.name) if self.workspace is not None: workspace_name = getattr(self.workspace, 'name', self.workspace) path_parts = "workspaces/{}/{}".format(workspace_name, path_parts) return urljoin( self.catalog.service_url, path_parts ) return url(self.catalog.service_url, path_parts) styles = xml_property("styles", _style_list) bounds = xml_property("bounds", bbox) abstract = xml_property("abstractTxt") title = xml_property("title") @property def layers(self): if "layers" in self.dirty: return self.dirty["layers"] else: if self.dom is None: self.fetch() node = self.dom.find(self._layer_parent) if node is not None: return _layer_list(node, self._layer_element) return None @layers.setter def _layers_setter(self, value): self.dirty["layers"] = value @layers.deleter def _layers_delete(self): self.dirty["layers"] = None def __str__(self): return "<LayerGroup {}>".format(self.name) __repr__ = __str__
class Coverage(ResourceInfo): def __init__(self, catalog, workspace, store, name): super(Coverage, self).__init__() self.catalog = catalog self.workspace = workspace self.store = store self.name = name @property def href(self): return url(self.catalog.service_url, [ "workspaces", self.workspace.name, "coveragestores", self.store.name, "coverages", self.name + ".xml" ]) resource_type = "coverage" save_method = "PUT" title = xml_property("title") abstract = xml_property("abstract") enabled = xml_property("enabled") advertised = xml_property("advertised") native_bbox = xml_property("nativeBoundingBox", bbox) latlon_bbox = xml_property("latLonBoundingBox", bbox) projection = xml_property("srs") projection_policy = xml_property("projectionPolicy") keywords = xml_property("keywords", string_list) request_srs_list = xml_property("requestSRS", string_list) response_srs_list = xml_property("responseSRS", string_list) supported_formats = xml_property("supportedFormats", string_list) metadata_links = xml_property("metadataLinks", metadata_link_list) writers = dict(title=write_string("title"), abstract=write_string("abstract"), enabled=write_bool("enabled"), nativeBoundingBox=write_bbox("nativeBoundingBox"), latLonBoundingBox=write_bbox("latLonBoundingBox"), srs=write_string("srs"), projection_policy=write_string("projectionPolicy"), keywords=write_string_list("keywords"), metadataLinks=write_metadata_link_list("metadataLinks"), requestSRS=write_string_list("requestSRS"), responseSRS=write_string_list("responseSRS"), supportedFormats=write_string_list("supportedFormats"))
class FeatureType(ResourceInfo): resource_type = "featureType" save_method = "PUT" def __init__(self, catalog, workspace, store, name): super(FeatureType, self).__init__() assert isinstance(store, ResourceInfo) assert isinstance(name, basestring) self.catalog = catalog self.workspace = workspace self.store = store self.name = name @property def href(self): return url(self.catalog.service_url, [ "workspaces", self.workspace.name, "datastores", self.store.name, "featuretypes", self.name + ".xml" ]) title = xml_property("title") abstract = xml_property("abstract") enabled = xml_property("enabled") advertised = xml_property("advertised") native_bbox = xml_property("nativeBoundingBox", bbox) latlon_bbox = xml_property("latLonBoundingBox", bbox) projection = xml_property("srs") projection_policy = xml_property("projectionPolicy") keywords = xml_property("keywords", string_list) attributes = xml_property("attributes", attribute_list) metadata_links = xml_property("metadataLinks", metadata_link_list) writers = dict(title=write_string("title"), abstract=write_string("abstract"), enabled=write_bool("enabled"), advertised=write_bool("advertised"), nativeBoundingBox=write_bbox("nativeBoundingBox"), latLonBoundingBox=write_bbox("latLonBoundingBox"), srs=write_string("srs"), projectionPolicy=write_string("projectionPolicy"), keywords=write_string_list("keywords"), metadataLinks=write_metadata_link_list("metadataLinks"))
class Layer(ResourceInfo): def __init__(self, catalog, name): super(Layer, self).__init__() self.catalog = catalog self.name = name resource_type = "layer" save_method = "PUT" @property def href(self): return "{}/layers/{}.xml".format(self.catalog.service_url, self.name) @property def resource(self): if self.dom is None: self.fetch() name = self.dom.find("resource/name").text atom_link = [ n for n in self.dom.find("resource").getchildren() if 'href' in n.attrib ] ws_name = workspace_from_url(atom_link[0].get('href')) return self.catalog.get_resources(names=name.split(":")[-1], workspaces=ws_name)[0] def _get_default_style(self): if 'default_style' in self.dirty: return self.dirty['default_style'] if self.dom is None: self.fetch() element = self.dom.find("defaultStyle") # aborted data uploads can result in no default style return self._resolve_style(element) if element is not None else None def _resolve_style(self, element): if ":" in element.find('name').text: ws_name, style_name = element.find('name').text.split(':') else: style_name = element.find('name').text ws_name = None atom_link = [n for n in element.getchildren() if 'href' in n.attrib] if atom_link and ws_name is None: ws_name = workspace_from_url(atom_link[0].get("href")) return self.catalog.get_styles(names=style_name, workspaces=ws_name)[0] def _set_default_style(self, style): if isinstance(style, Style): style = style.fqn self.dirty["default_style"] = style def _get_alternate_styles(self): if "alternate_styles" in self.dirty: return self.dirty["alternate_styles"] if self.dom is None: self.fetch() styles_list = self.dom.findall("styles/style") return [self._resolve_style(s) for s in styles_list] def _set_alternate_styles(self, styles): self.dirty["alternate_styles"] = styles default_style = property(_get_default_style, _set_default_style) styles = property(_get_alternate_styles, _set_alternate_styles) attribution_object = xml_property("attribution", _read_attribution) enabled = xml_property("enabled", lambda x: x.text == "true") advertised = xml_property("advertised", lambda x: x.text == "true", default=True) type = xml_property("type") def _get_attr_attribution(self): obj = { 'title': self.attribution_object.title, 'width': self.attribution_object.width, 'height': self.attribution_object.height, 'href': self.attribution_object.href, 'url': self.attribution_object.url, 'type': self.attribution_object.type } return obj def _set_attr_attribution(self, attribution): self.dirty["attribution"] = _attribution( attribution['title'], attribution['width'], attribution['height'], attribution['href'], attribution['url'], attribution['type']) assert self.attribution_object.title == attribution['title'] assert self.attribution_object.width == attribution['width'] assert self.attribution_object.height == attribution['height'] assert self.attribution_object.href == attribution['href'] assert self.attribution_object.url == attribution['url'] assert self.attribution_object.type == attribution['type'] attribution = property(_get_attr_attribution, _set_attr_attribution) writers = dict(attribution=_write_attribution, enabled=write_bool("enabled"), advertised=write_bool("advertised"), default_style=_write_default_style, alternate_styles=_write_alternate_styles)
class LayerGroup(ResourceInfo): """ Represents a layer group in geoserver """ resource_type = "layerGroup" save_method = "PUT" class Mode(): SINGLE = 'SINGLE' NAMED = 'NAMED' CONTAINER = 'CONTAINER' EO = 'EO' def __init__(self, catalog, name, workspace=None, title=None, abstractTxt=None, mode=Mode.SINGLE): super(LayerGroup, self).__init__() assert isinstance(name, basestring) self.catalog = catalog self.name = name self.title = title self.abstractTxt = abstractTxt self.mode = mode self.workspace = workspace # the XML format changed in 2.3.x - the element listing all the layers # and the entries themselves have changed if self.catalog.gsversion() == "2.2.x": parent, element, attributes = "layers", "layer", None else: parent, element, attributes = "publishables", "published", { 'type': 'layer' } self._layer_parent = parent self._layer_element = element self._layer_attributes = attributes self.writers = dict(name=write_string("name"), title=write_string("title"), abstractTxt=write_string("abstractTxt"), styles=_write_styles, layers=lambda b, l: _write_layers( b, l, parent, element, attributes), bounds=write_bbox("bounds"), workspace=write_string("workspace"), mode=write_string("mode")) @property def href(self): path_parts = ["layergroups", self.name + ".xml"] if self.workspace is not None: workspace_name = getattr(self.workspace, 'name', self.workspace) path_parts = ["workspaces", workspace_name] + path_parts return url(self.catalog.service_url, path_parts) styles = xml_property("styles", _style_list) bounds = xml_property("bounds", bbox) def _layers_getter(self): if "layers" in self.dirty: return self.dirty["layers"] else: if self.dom is None: self.fetch() node = self.dom.find(self._layer_parent) return _layer_list( node, self._layer_element) if node is not None else None def _layers_setter(self, value): self.dirty["layers"] = value def _layers_delete(self): self.dirty["layers"] = None layers = property(_layers_getter, _layers_setter, _layers_delete) def __str__(self): return "<LayerGroup %s>" % self.name __repr__ = __str__
class Layer(ResourceInfo): def __init__(self, catalog, name): super(Layer, self).__init__() self.catalog = catalog self.name = name resource_type = "layer" save_method = "PUT" @property def href(self): return url(self.catalog.service_url, ["layers", self.name + ".xml"]) @property def resource(self): if self.dom is None: self.fetch() name = self.dom.find("resource/name").text return self.catalog.get_resource(name) def _get_default_style(self): if 'default_style' in self.dirty: return self.dirty['default_style'] if self.dom is None: self.fetch() name = self.dom.find("defaultStyle/name") # aborted data uploads can result in no default style if name is not None: return self.catalog.get_style(name.text) else: return None def _set_default_style(self, style): if isinstance(style, Style): style = style.name self.dirty["default_style"] = style def _get_alternate_styles(self): if "alternate_styles" in self.dirty: return self.dirty["alternate_styles"] if self.dom is None: self.fetch() styles = self.dom.findall("styles/style/name") return [Style(self.catalog, s.text) for s in styles] def _set_alternate_styles(self, styles): self.dirty["alternate_styles"] = styles default_style = property(_get_default_style, _set_default_style) styles = property(_get_alternate_styles, _set_alternate_styles) attribution_object = xml_property("attribution", _read_attribution) enabled = xml_property("enabled", lambda x: x.text == "true") def _get_attr_text(self): return self.attribution_object.title def _set_attr_text(self, text): self.dirty["attribution"] = _attribution( text, self.attribution_object.width, self.attribution_object.height) assert self.attribution_object.title == text attribution = property(_get_attr_text, _set_attr_text) writers = dict(attribution=_write_attribution, enabled=write_bool("enabled"), default_style=_write_default_style, alternate_styles=_write_alternate_styles)
class Style(ResourceInfo): def __init__(self, catalog, name, workspace=None): super(Style, self).__init__() assert isinstance(name, basestring) self.catalog = catalog self.workspace = workspace self.name = name self._sld_dom = None @property def fqn(self): return self.name if not self.workspace else '%s:%s' % (self.workspace, self.name) @property def href(self): return self._build_href('.xml') def body_href(self): return self._build_href('.sld') @property def create_href(self): return self._build_href('.xml', True) def _build_href(self, extension, create=False): path_parts = ["styles"] query = {} if not create: path_parts.append(self.name + extension) else: query['name'] = self.name if self.workspace is not None: path_parts = [ "workspaces", getattr(self.workspace, 'name', self.workspace) ] + path_parts return url(self.catalog.service_url, path_parts, query) filename = xml_property("filename") def _get_sld_dom(self): if self._sld_dom is None: self._sld_dom = self.catalog.get_xml(self.body_href()) return self._sld_dom @property def sld_title(self): user_style = self._get_sld_dom().find( "{http://www.opengis.net/sld}NamedLayer/{http://www.opengis.net/sld}UserStyle" ) if not user_style: user_style = self._get_sld_dom().find( "{http://www.opengis.net/sld}UserLayer/{http://www.opengis.net/sld}UserStyle" ) if user_style: title_node = user_style.find("{http://www.opengis.net/sld}Title") return title_node.text if title_node is not None else None @property def sld_name(self): user_style = self._get_sld_dom().find( "{http://www.opengis.net/sld}NamedLayer/{http://www.opengis.net/sld}UserStyle" ) if not user_style: user_style = self._get_sld_dom().find( "{http://www.opengis.net/sld}UserLayer/{http://www.opengis.net/sld}UserStyle" ) if user_style: name_node = user_style.find("{http://www.opengis.net/sld}Name") return name_node.text if name_node is not None else None @property def sld_body(self): content = self.catalog.http.request(self.body_href())[1] return content def update_body(self, body): headers = {"Content-Type": "application/vnd.ogc.sld+xml"} self.catalog.http.request(self.body_href(), "PUT", body, headers)
class Style(ResourceInfo): supported_formats = ["sld10", "sld11", "zip"] content_types = { "sld10": "application/vnd.ogc.sld+xml", "sld11": "application/vnd.ogc.se+xml", "zip": "application/zip", } def __init__(self, catalog, name, workspace=None, style_format="sld10"): super(Style, self).__init__() assert isinstance(name, str) assert style_format in self.supported_formats self.catalog = catalog self.workspace = workspace self.name = name self.style_format = style_format self._sld_dom = None @property def fqn(self): if not self.workspace: return self.name return "{}:{}".format(self.workspace, self.name) @property def href(self): return self._build_href(".xml") @property def body_href(self): return self._build_href(".sld") @property def create_href(self): return self._build_href(".xml", True) @property def content_type(self): return Style.content_types[self.style_format] def _build_href(self, extension, create=False): url_part = "styles/" if not create: url_part += "{}{}".format(self.name, extension) else: url_part += "?name={}".format(self.name) if self.workspace is not None: url_part = "workspaces/{}/{}".format( getattr(self.workspace, "name", self.workspace), url_part) return urljoin(self.catalog.service_url, url_part) filename = xml_property("filename") def _get_sld_dom(self): if self._sld_dom is None: self._sld_dom = self.catalog.get_xml(self.body_href) return self._sld_dom @property def sld_title(self): user_style = self._get_sld_dom().find( "{http://www.opengis.net/sld}NamedLayer/{http://www.opengis.net/sld}UserStyle" ) if not user_style: user_style = self._get_sld_dom().find( "{http://www.opengis.net/sld}UserLayer/{http://www.opengis.net/sld}UserStyle" ) if user_style: try: # it is not mandatory title_node = user_style.find( "{http://www.opengis.net/sld}Title") except: title_node = None if title_node is not None: title_node = title_node.text return title_node @property def sld_name(self): user_style = self._get_sld_dom().find( "{http://www.opengis.net/sld}NamedLayer/{http://www.opengis.net/sld}UserStyle" ) if not user_style: user_style = self._get_sld_dom().find( "{http://www.opengis.net/sld}UserLayer/{http://www.opengis.net/sld}UserStyle" ) if user_style: try: # it is not mandatory name_node = user_style.find("{http://www.opengis.net/sld}Name") except: name_node = None if name_node is not None: name_node = name_node.text return name_node @property def sld_body(self): return self.catalog.session.get(self.body_href).text def update_body(self, body): headers = {"Content-Type": self.content_type} self.catalog.session.put(self.body_href, data=body, headers=headers)
class WmsStore(ResourceInfo): resource_type = "wmsStore" save_method = "PUT" def __init__(self, catalog, workspace, name, user, password): super(WmsStore, self).__init__() assert isinstance(workspace, ws.Workspace) assert isinstance(name, basestring) self.catalog = catalog self.workspace = workspace self.name = name self.metadata = {} self.metadata['user'] = user self.metadata['password'] = password @property def href(self): return "%s/workspaces/%s/wmsstores/%s.xml" % ( self.catalog.service_url, self.workspace.name, self.name) enabled = xml_property("enabled", lambda x: x.text == "true") name = xml_property("name") capabilitiesURL = xml_property("capabilitiesURL") type = xml_property("type") metadata = xml_property("metadata", key_value_pairs) writers = dict(enabled=write_bool("enabled"), name=write_string("name"), capabilitiesURL=write_string("capabilitiesURL"), type=write_string("type"), metadata=write_dict("metadata")) def get_resources(self, name=None, available=False): res_url = "%s/workspaces/%s/wmsstores/%s/wmslayers.xml" % ( self.catalog.service_url, self.workspace.name, self.name) layer_name_attr = "wmsLayer" if available: res_url += "?list=available" layer_name_attr += 'Name' xml = self.catalog.get_xml(res_url) def wl_from_node(node): return wmslayer_from_index(self.catalog, self.workspace, self, node) #if name passed, return only one layer, otherwise return all layers in store: if name is not None: for node in xml.findall(layer_name_attr): if node.findtext("name") == name: return wl_from_node(node) return None if available: return [str(node.text) for node in xml.findall(layer_name_attr)] else: return [ wl_from_node(node) for node in xml.findall(layer_name_attr) ]
class Style(ResourceInfo): supported_formats = ["sld10", "sld11", "zip"] content_types = { "sld10": "application/vnd.ogc.sld+xml", "sld11": "application/vnd.ogc.se+xml", "zip": "application/zip" } def __init__(self, catalog, name, workspace=None, style_format="sld10"): super(Style, self).__init__() assert isinstance(name, basestring) assert style_format in Style.supported_formats self.catalog = catalog self.workspace = workspace self.name = name self.style_format = style_format self._sld_dom = None @property def fqn(self): if not self.workspace: return self.name return '{}:{}'.format(self.workspace, self.name) @property def href(self): return self._build_href('.xml') @property def body_href(self): return self._build_href('.sld') @property def create_href(self): return self._build_href('.xml', True) @property def content_type(self): return Style.content_types[self.style_format] def _build_href(self, extension, create=False): path_parts = ["styles"] query = {} if not create: path_parts.append(self.name + extension) else: query['name'] = self.name if self.workspace is not None: path_parts = ["workspaces", getattr(self.workspace, 'name', self.workspace)] + path_parts return build_url(self.catalog.service_url, path_parts, query) filename = xml_property("filename") def _get_sld_dom(self): if self._sld_dom is None: self._sld_dom = self.catalog.get_xml(self.body_href) return self._sld_dom @property def sld_title(self): user_style = self._get_sld_dom().find("{http://www.opengis.net/sld}NamedLayer/{http://www.opengis.net/sld}UserStyle") if not user_style: user_style = self._get_sld_dom().find("{http://www.opengis.net/sld}UserLayer/{http://www.opengis.net/sld}UserStyle") title_node = None if user_style: try: # it is not mandatory title_node = user_style.find("{http://www.opengis.net/sld}Title") except AttributeError: title_node = None return title_node.text if title_node is not None else None @property def sld_name(self): user_style = self._get_sld_dom().find("{http://www.opengis.net/sld}NamedLayer/{http://www.opengis.net/sld}UserStyle") if not user_style: user_style = self._get_sld_dom().find("{http://www.opengis.net/sld}UserLayer/{http://www.opengis.net/sld}UserStyle") name_node = None if user_style: try: # it is not mandatory name_node = user_style.find("{http://www.opengis.net/sld}Name") except AttributeError: name_node = None return name_node.text if name_node is not None else None @property def sld_body(self): resp = self.catalog.http_request(self.body_href) return resp.content def update_body(self, body): headers = {"Content-Type": self.content_type} self.catalog.http.request( self.body_href, "PUT", body, headers)