From 79174bdcb8deb46b0a362cbe527b69cc77c236ec Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Ma=C3=ABl=20M=C3=A9liani?= <m.meliani@neogeo-online.net>
Date: Wed, 5 Jun 2013 15:00:06 +0200
Subject: [PATCH] Renamed Coverage and FeatureType in mapfile.py to
CoverageModel and FeatureTypeModel.
---
src/mapfile.py | 64 +++++++++++++++++++++++++-------------------------
src/server.py | 22 ++++++++---------
2 files changed, 43 insertions(+), 43 deletions(-)
diff --git a/src/mapfile.py b/src/mapfile.py
index d787cf0..ac5314b 100644
--- a/src/mapfile.py
+++ b/src/mapfile.py
@@ -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)
diff --git a/src/server.py b/src/server.py
index 901370f..787da9b 100755
--- a/src/server.py
+++ b/src/server.py
@@ -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()
--
GitLab