def POST(self, format):
"""Create a new workspace."""
data = get_data(name="workspace", mandatory=["name"], authorized=["name"])
ws_name = data.pop("name")
with webapp.mightConflict():
mra.create_workspace(ws_name).save()
webapp.Created("%s/workspaces/%s.%s" % (web.ctx.home, ws_name, format))
def POST(self, format):
"""Create a new SLD style. Add the 'name' parameter in order to specify
the name to be given to the new style.
"""
params = web.input(name=None)
name = params.name
if name == None:
raise webapp.BadRequest(message="no parameter \"name\" given.")
data = web.data()
mra.create_style(name, data)
webapp.Created("%s/styles/%s.%s" % (web.ctx.home, name, format))
def POST(self, ws_name, format):
"""Create a new data store."""
ws = get_workspace(ws_name)
data = get_data(name="dataStore", mandatory=["name"],
authorized=["name", "title", "abstract", "connectionParameters"])
ds_name = data.pop("name")
with webapp.mightConflict("dataStore", workspace=ws_name):
ws.create_datastore(ds_name, data)
ws.save()
webapp.Created("%s/workspaces/%s/datastores/%s.%s" % (
web.ctx.home, ws_name, ds_name, format))
def POST(self, format):
"""Create a new layer group."""
mf = mra.get_available()
data = get_data(name="layerGroup", mandatory=["name"], authorized=["name", "title", "abstract", "layers"])
lg_name = data.pop("name")
with webapp.mightNotFound():
layers = [mf.get_layer(l_name) for l_name in data.pop("layers", [])]
with webapp.mightConflict():
lg = mf.create_layergroup(lg_name, data)
lg.add(*layers)
mf.save()
webapp.Created("%s/layergroups/%s.%s" % (web.ctx.home, lg.name, format))
def POST(self, format):
"""Create a new layer."""
data = get_data(name="layer",
mandatory=["name", "resource"],
authorized=["name", "title", "abstract", "resource", "enabled", "defaultStyle"])
l_name = data.pop("name")
l_enabled = data.pop("enabled", True)
href = data["resource"]["href"]
try:
ws_name, st_type, st_name, r_type, r_name = mra.href_parse(href, 5)
except ValueError:
raise webapp.NotFound(message="resource \"%s\" was not found." % href)
st_type, r_type = st_type[:-1], r_type[:-1] # Remove trailing s.
ws = get_workspace(ws_name)
with webapp.mightNotFound(r_type, workspace=ws_name):
try:
model = ws.get_layermodel(r_type, st_name, r_name)
except ValueError:
raise KeyError(r_type)
mf = mra.get_available()
with webapp.mightConflict():
mf.create_layer(model, l_name, l_enabled)
# If we have a defaultStyle apply it.
s_name = data.get("defaultStyle", {}).get("name")
if s_name:
with webapp.mightNotFound():
style = mra.get_style(s_name)
layer = mf.get_layer(l_name)
layer.add_style_sld(mf, s_name, style)
# Remove the automatic default style.
for s_name in layer.iter_styles():
if s_name == tools.get_dflt_sld_name(layer.ms.type):
layer.remove_style(s_name)
mf.save()
webapp.Created("%s/layers/%s.%s" % (web.ctx.home, l_name, format))
def POST(self, ws_name, cs_name, format):
"""Create a new coverage."""
ws = get_workspace(ws_name)
data = get_data(name="coverage", mandatory=["name"], authorized=["name", "title", "abstract"])
with webapp.mightConflict("coverage", coveragestore=cs_name):
with webapp.mightNotFound("coverage", coveragestore=cs_name):
ws.create_coveragemodel(data["name"], cs_name, data)
ws.save()
# Then creates the associated layer by default:
model = ws.get_coveragemodel(cs_name, data["name"])
mf = mra.get_available()
with webapp.mightConflict():
mf.create_layer(model, data["name"], True)
mf.save()
webapp.Created("%s/workspaces/%s/coveragestores/%s/coverages/%s.%s" % (
web.ctx.home, ws.name, cs_name, data["name"], format))
def POST(self, ws_name, format):
"""Create new coverage store."""
ws = get_workspace(ws_name)
data = get_data(name="coverageStore", mandatory=["name"], authorized=["name", "title", "abstract", "connectionParameters"])
cs_name = data.pop("name")
with webapp.mightConflict("coverageStore", workspace=ws_name):
ws.create_coveragestore(cs_name, data)
ws.save()
# Then creates the associated layer by default:
# model = ws.get_coveragetypemodel(cs_name, data["name"])
# mf = mra.get_available()
# with webapp.mightConflict():
# mf.create_layer(model, data["name"], True)
# mf.save()
webapp.Created("%s/workspaces/%s/coveragestores/%s.%s" % (
web.ctx.home, ws_name, cs_name, format))
def POST(self, ws_name, ds_name, format):
"""Create a new feature type. It create the associated layer by defaut.
This layer is added in the mapfile: <layer.map>
"""
ws = get_workspace(ws_name)
data = get_data(name="featureType", mandatory=["name"],
authorized=["name", "title", "abstract"])
# Creates first the feature type:
with webapp.mightConflict("featureType", datastore=ds_name):
with webapp.mightNotFound("featureType", datastore=ds_name):
ws.create_featuretypemodel(ds_name, data["name"], data)
ws.save()
# Then creates the associated layer by default:
model = ws.get_featuretypemodel(ds_name, data["name"])
mf = mra.get_available()
with webapp.mightConflict():
mf.create_layer(model, data["name"], True)
mf.save()
webapp.Created("%s/workspaces/%s/datastores/%s/featuretypes/%s.%s" % (
web.ctx.home, ws.name, ds_name, data["name"], format))