Skip to content
Snippets Groups Projects
Commit 79174bdc authored by Maël Méliani's avatar Maël Méliani
Browse files

Renamed Coverage and FeatureType in mapfile.py to CoverageModel and FeatureTypeModel.

parent acc6158e
No related branches found
No related tags found
No related merge requests found
Hide whitespace changes
Inline Side-by-side
src/mapfile.py
+ 32
− 32
View file @ 79174bdc
......@@ -292,7 +292,7 @@ class LayerModel(MetadataMixin):
return layer
class FeatureType(LayerModel):
class FeatureTypeModel(LayerModel):
"""
"""
......@@ -398,7 +398,7 @@ class FeatureType(LayerModel):
class Coverage(LayerModel):
class CoverageModel(LayerModel):
"""
"""
......@@ -585,42 +585,42 @@ class MapfileWorkspace(Workspace):
# Feature types
def iter_featuretypes(self, ds_name=None, **kwargs):
def iter_featuretypemodels(self, ds_name=None, **kwargs):
kwargs.setdefault("mra", {}).update({"type":"featuretype", "is_model":True})
if ds_name != None:
kwargs["mra"].update({"storage":ds_name, "workspace":self.name})
for ms_layer in self.mapfile.iter_ms_layers(**kwargs):
yield FeatureType(ms_layer)
yield FeatureTypeModel(ms_layer)
def get_featuretype(self, ft_name, ds_name):
def get_featuretypemodel(self, ft_name, ds_name):
# Improvement: Use get by name combined with a coverage-specific naming.
try:
return next(self.iter_featuretypes(ds_name, mra={"name":ft_name}))
return next(self.iter_featuretypemodels(ds_name, mra={"name":ft_name}))
except StopIteration:
raise KeyError((ds_name, ft_name))
def has_featuretype(self, ft_name, ds_name):
# Improvement: See get_featuretype
def has_featuretypemodel(self, ft_name, ds_name):
# Improvement: See get_featuretypemodel
try:
self.get_featuretype(ft_name, ds_name)
self.get_featuretypemodel(ft_name, ds_name)
except KeyError:
return False
else:
return True
def create_featuretype(self, ft_name, ds_name, metadata={}):
if self.has_featuretype(ft_name, ds_name):
def create_featuretypemodel(self, ft_name, ds_name, metadata={}):
if self.has_featuretypemodel(ft_name, ds_name):
raise KeyExists(ft_name)
ft = FeatureType(mapscript.layerObj(self.mapfile.ms))
ft = FeatureTypeModel(mapscript.layerObj(self.mapfile.ms))
ft.update(self, ft_name, ds_name, metadata)
return ft
def update_featuretype(self, ft_name, ds_name, metadata={}):
ft = self.get_featuretype(ft_name, ds_name)
def update_featuretypemodel(self, ft_name, ds_name, metadata={}):
ft = self.get_featuretypemodel(ft_name, ds_name)
ft.update(self, ft_name, ds_name, metadata)
def delete_featuretype(self, ft_name, ds_name):
def delete_featuretypemodel(self, ft_name, ds_name):
try:
next(self.mapfile.iter_layers(mra={"workspace":self.name, "type":"featuretype",
"storage":ds_name, "name":ft_name}))
......@@ -629,48 +629,48 @@ class MapfileWorkspace(Workspace):
else:
raise ValueError("The featuretype '%s' can't be delete because it is used." % ft_name)
ft = self.get_featuretype(ft_name, ds_name)
ft = self.get_featuretypemodel(ft_name, ds_name)
self.mapfile.ms.removeLayer(ft.ms.index)
# Coverages
def iter_coverages(self, cs_name=None, **kwargs):
def iter_coveragemodels(self, cs_name=None, **kwargs):
kwargs.setdefault("mra", {}).update({"type":"coverage", "is_model":True})
if cs_name != None:
kwargs["mra"].update({"storage":cs_name, "workspace":self.name})
for ms_layer in self.mapfile.iter_ms_layers(**kwargs):
yield Coverage(ms_layer)
yield CoverageModel(ms_layer)
def get_coverage(self, c_name, cs_name):
def get_coveragemodel(self, c_name, cs_name):
# Improvement: Use get by name combined with a coverage-specific naming.
try:
return next(self.iter_coverages(cs_name, mra={"name":c_name}))
return next(self.iter_coveragemodels(cs_name, mra={"name":c_name}))
except StopIteration:
raise KeyError((cs_name, c_name))
def has_coverage(self, c_name, cs_name):
# Improvement: See get_coverage
def has_coveragemodel(self, c_name, cs_name):
# Improvement: See get_coveragemodel
try:
self.get_coverage(c_name, cs_name)
self.get_coveragemodel(c_name, cs_name)
except KeyError:
return False
else:
return True
def create_coverage(self, c_name, cs_name, metadata={}):
if self.has_coverage(c_name, cs_name):
def create_coveragemodel(self, c_name, cs_name, metadata={}):
if self.has_coveragemodel(c_name, cs_name):
raise KeyExists(c_name)
c = Coverage(mapscript.layerObj(self.mapfile.ms))
c = CoverageModel(mapscript.layerObj(self.mapfile.ms))
c.update(self, c_name, cs_name, metadata)
return c
def update_coverage(self, c_name, cs_name, metadata={}):
c = self.get_coverage(c_name, cs_name)
def update_coveragemodel(self, c_name, cs_name, metadata={}):
c = self.get_coveragemodel(c_name, cs_name)
c.update(self, c_name, cs_name, metadata)
def delete_coverage(self, c_name, cs_name):
def delete_coveragemodel(self, c_name, cs_name):
try:
next(self.mapfile.iter_layers(mra={"workspace":self.name, "type":"coverage",
"storage":cs_name, "name":c_name}))
......@@ -679,7 +679,7 @@ class MapfileWorkspace(Workspace):
else:
raise ValueError("The coverage '%s' can't be delete because it is used." % c_name)
c = self.get_coverage(c_name, cs_name)
c = self.get_coveragemodel(c_name, cs_name)
self.mapfile.ms.removeLayer(c.ms.index)
# All the above :)
......@@ -687,9 +687,9 @@ class MapfileWorkspace(Workspace):
def get_model(self, m_name, s_type, s_name):
if s_type == "coverage":
return self.get_coverage(m_name, s_name)
return self.get_coveragemodel(m_name, s_name)
elif s_type == "featuretype":
return self.get_featuretype(m_name, s_name)
return self.get_featuretypemodel(m_name, s_name)
else:
raise ValueError("Bad storage type '%s'." % s_type)
......
src/server.py
+ 11
− 11
View file @ 79174bdc
......@@ -189,7 +189,7 @@ class datastore(object):
mf, ws = get_mapfile_workspace(map_name, ws_name)
# We need to check if this datatore is empty.
assert_is_empty(ws.iter_featuretypes(ds_name=ds_name), "datastore", ds_name)
assert_is_empty(ws.iter_featuretypemodels(ds_name=ds_name), "datastore", ds_name)
with webapp.mightNotFound("dataStore", workspace=ws_name):
ws.delete_datastore(ds_name)
......@@ -204,7 +204,7 @@ class featuretypes(object):
"name": ft.name,
"href": "%s/maps/%s/workspaces/%s/datastores/%s/featuretypes/%s.%s" % (
web.ctx.home, map_name, ws.name, ds_name, ft.name, format)
} for ft in ws.iter_featuretypes(ds_name)]
} for ft in ws.iter_featuretypemodels(ds_name)]
}
def POST(self, map_name, ws_name, ds_name, format):
......@@ -213,7 +213,7 @@ class featuretypes(object):
data = get_data(name="featureType", mandatory=["name"])
with webapp.mightConflict("featureType", datastore=ds_name):
with webapp.mightNotFound("featureType", datastore=ds_name):
ws.create_featuretype(data["name"], ds_name, data)
ws.create_featuretypemodel(data["name"], ds_name, data)
ws.save()
webapp.Created("%s/maps/%s/workspaces/%s/datastores/%s/featuretypes/%s%s" % (
......@@ -225,7 +225,7 @@ class featuretype(object):
def GET(self, map_name, ws_name, ds_name, ft_name, format):
mf, ws = get_mapfile_workspace(map_name, ws_name)
with webapp.mightNotFound("featureType", datastore=ds_name):
ft = ws.get_featuretype(ft_name, ds_name)
ft = ws.get_featuretypemodel(ft_name, ds_name)
ds = ws.get_datastore(ds_name)
with webapp.mightNotFound("dataStore", datastore=ds_name):
......@@ -289,7 +289,7 @@ class featuretype(object):
metadata = dict((k, v) for k, v in data.iteritems() if k in ["title", "abstract"])
with webapp.mightNotFound("featureType", datastore=ds_name):
ws.update_featuretype(ft_name, ds_name, metadata)
ws.update_featuretypemodel(ft_name, ds_name, metadata)
ws.save()
def DELETE(self, map_name, ws_name, ds_name, ft_name, format):
......@@ -300,7 +300,7 @@ class featuretype(object):
"featuretype", ft_name)
with webapp.mightNotFound("featureType", datastore=ds_name):
ws.delete_featuretype(ft_name, ds_name)
ws.delete_featuretypemodel(ft_name, ds_name)
ws.save()
......@@ -373,7 +373,7 @@ class coverages(object):
"name": c.name,
"href": "%s/maps/%s/workspaces/%s/coveragestores/%s/coverages/%s.%s" % (
web.ctx.home, map_name, ws.name, cs_name, c.name, format)
} for c in ws.iter_coverages(cs_name)]
} for c in ws.iter_coveragemodels(cs_name)]
}
def POST(self, map_name, ws_name, cs_name, format):
......@@ -382,7 +382,7 @@ class coverages(object):
data = get_data(name="coverage", mandatory=["name"])
with webapp.mightConflict("coverage", coveragestore=cs_name):
ws.create_coverage(data["name"], cs_name, data)
ws.create_coveragemodel(data["name"], cs_name, data)
ws.save()
webapp.Created("%s/maps/%s/workspaces/%s/coveragestores/%s/coverages/%s%s" % (
......@@ -394,7 +394,7 @@ class coverage(object):
def GET(self, map_name, ws_name, cs_name, c_name, format):
mf, ws = get_mapfile_workspace(map_name, ws_name)
with webapp.mightNotFound("coverage", coveragestore=cs_name):
c = ws.get_coverage(c_name, cs_name)
c = ws.get_coveragemodel(c_name, cs_name)
with webapp.mightNotFound("coveragestore", workspace=ws_name):
cs = ws.get_coveragestore(cs_name)
......@@ -447,7 +447,7 @@ class coverage(object):
metadata = dict((k, v) for k, v in data.iteritems() if k in ["title", "abstract"])
with webapp.mightNotFound("coverage", coveragestore=cs_name):
ws.update_coverage(c_name, cs_name, metadata)
ws.update_coveragemodel(c_name, cs_name, metadata)
ws.save()
def DELETE(self, map_name, ws_name, cs_name, c_name, format):
......@@ -458,7 +458,7 @@ class coverage(object):
"coverage", ft_name)
with webapp.mightNotFound("coverage", coveragestore=cs_name):
ws.delete_coverage(c_name, cs_name)
ws.delete_coveragemodel(c_name, cs_name)
ws.save()
......
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment