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)
