def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(request, layername, 'layers.change_layer',
_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
return render_to_response(
template,
RequestContext(request, {
'layer': layer,
'is_featuretype': layer.is_vector()
}))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = save(layer,
base_file,
request.user,
overwrite=True)
except Exception, e:
out['success'] = False
out['errors'] = str(e)
else:
out['success'] = True
out['url'] = reverse('layer_detail',
args=[saved_layer.typename])
finally:
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(request, layername, 'base.change_resourcebase',_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
return render_to_response(template,
RequestContext(request, {'layer': layer,
'is_featuretype': layer.is_vector()}))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = file_upload(base_file, name=layer.name,
user=request.user, overwrite=True)
except Exception, e:
out['success'] = False
out['errors'] = str(e)
else:
out['success'] = True
out['url'] = reverse('layer_detail', args=[saved_layer.service_typename])
finally:
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(request, layername, 'layers.change_layer',_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
cat = Layer.objects.gs_catalog
info = cat.get_resource(layer.name)
is_featuretype = info.resource_type == FeatureType.resource_type
return render_to_response(template,
RequestContext(request, {'layer': layer,
'is_featuretype': is_featuretype}))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = save(layer, base_file, request.user, overwrite=True,
permissions=layer.get_all_level_info())
except Exception, e:
out['success'] = False
out['errors'] = str(e)
else:
out['success'] = True
out['url'] = reverse('layer_detail', args=[saved_layer.typename])
finally:
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(request, layername, 'layers.change_layer',_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
cat = Layer.objects.gs_catalog
info = cat.get_resource(layer.name)
is_featuretype = info.resource_type == FeatureType.resource_type
return render_to_response(template,
RequestContext(request, {'layer': layer,
'is_featuretype': is_featuretype}))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = save(layer, base_file, request.user, overwrite=True,
permissions=layer.get_all_level_info())
return HttpResponse(json.dumps({
"success": True,
"redirect_to": reverse('layer_metadata', args=[saved_layer.typename])}))
except Exception, e:
logger.info("Unexpected error during upload.")
return HttpResponse(json.dumps({
"success": False,
"errors": ["Unexpected error during upload: " + escape(str(e))]}))
finally:
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(request, layername, 'layers.change_layer',_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
cat = Layer.objects.gs_catalog
info = cat.get_resource(layer.name)
is_featuretype = info.resource_type == FeatureType.resource_type
return render_to_response(template,
RequestContext(request, {'layer': layer,
'is_featuretype': is_featuretype}))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = save(layer, base_file, request.user, overwrite=True,
permissions=layer.get_all_level_info())
except Exception, e:
out['success'] = False
out['errors'] = str(e)
else:
out['success'] = True
out['url'] = reverse('layer_detail', args=[saved_layer.typename])
finally:
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(
request,
layername,
'base.change_resourcebase',
_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
ctx = {
'charsets': CHARSETS,
'layer': layer,
'is_featuretype': layer.is_vector(),
'is_layer': True,
}
return render_to_response(template,
RequestContext(request, ctx))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = file_upload(
base_file,
name=layer.name,
user=request.user,
overwrite=True,
charset=form.cleaned_data["charset"],
)
except Exception as e:
out['success'] = False
out['errors'] = str(e)
else:
out['success'] = True
out['url'] = reverse(
'layer_detail', args=[
saved_layer.service_typename])
finally:
if tempdir is not None:
shutil.rmtree(tempdir)
else:
errormsgs = []
for e in form.errors.values():
errormsgs.append([escape(v) for v in e])
out['errors'] = form.errors
out['errormsgs'] = errormsgs
if out['success']:
status_code = 200
else:
status_code = 500
return HttpResponse(
json.dumps(out),
mimetype='application/json',
status=status_code)
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(
request,
layername,
'base.change_resourcebase',
_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
ctx = {
'charsets': CHARSETS,
'layer': layer,
'is_featuretype': layer.is_vector()
}
return render_to_response(template,
RequestContext(request, ctx))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = file_upload(
base_file,
name=layer.name,
user=request.user,
overwrite=True,
charset=form.cleaned_data["charset"],
)
except Exception as e:
out['success'] = False
out['errors'] = str(e)
else:
out['success'] = True
out['url'] = reverse(
'layer_detail', args=[
saved_layer.service_typename])
finally:
if tempdir is not None:
shutil.rmtree(tempdir)
else:
errormsgs = []
for e in form.errors.values():
errormsgs.append([escape(v) for v in e])
out['errors'] = form.errors
out['errormsgs'] = errormsgs
if out['success']:
status_code = 200
else:
status_code = 500
return HttpResponse(
json.dumps(out),
mimetype='application/json',
status=status_code)
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(
request,
layername,
'base.change_resourcebase_permissions',
_PERMISSION_MSG_MODIFY)
try:
if "permission_denied" in layer:
return HttpResponse('You are not allowed to replace this layer',
mimetype="text/plain",
status=401)
except:
pass
if request.method == 'GET':
return render_to_response(
template, RequestContext(
request, {
'layer': layer, 'is_featuretype': layer.is_vector()}))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = file_upload(base_file, name=layer.name,
user=request.user, overwrite=True)
except Exception as e:
out['success'] = False
out['errors'] = str(e)
else:
out['success'] = True
out['url'] = reverse(
'layer_detail', args=[
saved_layer.service_typename])
finally:
if tempdir is not None:
shutil.rmtree(tempdir)
else:
errormsgs = []
for e in form.errors.values():
errormsgs.append([escape(v) for v in e])
out['errors'] = form.errors
out['errormsgs'] = errormsgs
if out['success']:
status_code = 200
else:
status_code = 500
return HttpResponse(
json.dumps(out),
mimetype='application/json',
status=status_code)
def testWriteFiles(self):
files = dict(base_file=SimpleUploadedFile('foo.shp', ' '),
shx_file=SimpleUploadedFile('foo.shx', ' '),
dbf_file=SimpleUploadedFile('foo.dbf', ' '),
prj_file=SimpleUploadedFile('foo.prj', ' '))
form = LayerUploadForm(dict(), files)
self.assertTrue(form.is_valid())
tempdir = form.write_files()[0]
self.assertEquals(set(os.listdir(tempdir)),
set(['foo.shp', 'foo.shx', 'foo.dbf', 'foo.prj']))
def layer_replace(request, layername, template="layers/layer_replace.html"):
layer = _resolve_layer(request, layername, "base.change_resourcebase", _PERMISSION_MSG_MODIFY)
if request.method == "GET":
ctx = {"charsets": CHARSETS, "layer": layer, "is_featuretype": layer.is_vector(), "is_layer": True}
return render_to_response(template, RequestContext(request, ctx))
elif request.method == "POST":
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
if layer.is_vector() and is_raster(base_file):
out["success"] = False
out["errors"] = _("You are attempting to replace a vector layer with a raster.")
elif (not layer.is_vector()) and is_vector(base_file):
out["success"] = False
out["errors"] = _("You are attempting to replace a raster layer with a vector.")
else:
# delete geoserver's store before upload
cat = gs_catalog
cascading_delete(cat, layer.typename)
saved_layer = file_upload(
base_file,
name=layer.name,
user=request.user,
overwrite=True,
charset=form.cleaned_data["charset"],
)
out["success"] = True
out["url"] = reverse("layer_detail", args=[saved_layer.service_typename])
except Exception as e:
out["success"] = False
out["errors"] = str(e)
finally:
if tempdir is not None:
shutil.rmtree(tempdir)
else:
errormsgs = []
for e in form.errors.values():
errormsgs.append([escape(v) for v in e])
out["errors"] = form.errors
out["errormsgs"] = errormsgs
if out["success"]:
status_code = 200
else:
status_code = 400
return HttpResponse(json.dumps(out), mimetype="application/json", status=status_code)
def testWriteFiles(self):
files = dict(
base_file=SimpleUploadedFile('foo.shp', ' '),
shx_file=SimpleUploadedFile('foo.shx', ' '),
dbf_file=SimpleUploadedFile('foo.dbf', ' '),
prj_file=SimpleUploadedFile('foo.prj', ' '))
form = LayerUploadForm(dict(), files)
self.assertTrue(form.is_valid())
tempdir = form.write_files()[0]
self.assertEquals(set(os.listdir(tempdir)),
set(['foo.shp', 'foo.shx', 'foo.dbf', 'foo.prj']))
def testWriteFiles(self):
files = dict(base_file=SimpleUploadedFile('foo.shp', ' '),
shx_file=SimpleUploadedFile('foo.shx', ' '),
dbf_file=SimpleUploadedFile('foo.dbf', ' '),
prj_file=SimpleUploadedFile('foo.prj', ' '))
form = LayerUploadForm(dict(), files)
self.assertTrue(form.is_valid())
tempdir = form.write_files()[0]
self.assertEquals(set(os.listdir(tempdir)),
set(['foo.shp', 'foo.shx', 'foo.dbf', 'foo.prj']))
the_zip = zipfile.ZipFile('test_upload.zip', 'w')
in_memory_file = StringIO.StringIO()
in_memory_file.write('test')
the_zip.writestr('foo.shp', in_memory_file.getvalue())
the_zip.writestr('foo.dbf', in_memory_file.getvalue())
the_zip.writestr('foo.shx', in_memory_file.getvalue())
the_zip.writestr('foo.prj', in_memory_file.getvalue())
the_zip.close()
files = dict(
base_file=SimpleUploadedFile('test_upload.zip',
open('test_upload.zip').read()))
form = LayerUploadForm(dict(), files)
self.assertTrue(form.is_valid())
tempdir = form.write_files()[0]
self.assertEquals(set(os.listdir(tempdir)),
set(['foo.shp', 'foo.shx', 'foo.dbf', 'foo.prj']))
os.remove('test_upload.zip')
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(request, layername, 'layers.change_layer',
_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
cat = Layer.objects.gs_catalog
info = cat.get_resource(layer.name)
is_featuretype = info.resource_type == FeatureType.resource_type
return render_to_response(
template,
RequestContext(request, {
'layer': layer,
'is_featuretype': is_featuretype
}))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
if form.is_valid():
try:
tempdir, base_file = form.write_files()
saved_layer = save(layer,
base_file,
request.user,
overwrite=True,
permissions=layer.get_all_level_info())
return HttpResponse(
json.dumps({
"success":
True,
"redirect_to":
reverse('layer_metadata', args=[saved_layer.typename])
}))
except Exception, e:
logger.info("Unexpected error during upload.")
return HttpResponse(
json.dumps({
"success":
False,
"errors":
["Unexpected error during upload: " + escape(str(e))]
}))
finally:
def testZipValidation(self):
the_zip = zipfile.ZipFile('test_upload.zip', 'w')
in_memory_file = StringIO.StringIO()
in_memory_file.write('test')
the_zip.writestr('foo.shp', in_memory_file.getvalue())
the_zip.writestr('foo.dbf', in_memory_file.getvalue())
the_zip.writestr('foo.shx', in_memory_file.getvalue())
the_zip.writestr('foo.prj', in_memory_file.getvalue())
the_zip.close()
files = dict(base_file=SimpleUploadedFile('test_upload.zip', open('test_upload.zip').read()))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
os.remove('test_upload.zip')
def testWriteFiles(self):
files = dict(
base_file=SimpleUploadedFile("foo.shp", " "),
shx_file=SimpleUploadedFile("foo.shx", " "),
dbf_file=SimpleUploadedFile("foo.dbf", " "),
prj_file=SimpleUploadedFile("foo.prj", " "),
)
form = LayerUploadForm(dict(), files)
self.assertTrue(form.is_valid())
tempdir = form.write_files()[0]
self.assertEquals(set(os.listdir(tempdir)), set(["foo.shp", "foo.shx", "foo.dbf", "foo.prj"]))
the_zip = zipfile.ZipFile("test_upload.zip", "w")
in_memory_file = StringIO.StringIO()
in_memory_file.write("test")
the_zip.writestr("foo.shp", in_memory_file.getvalue())
the_zip.writestr("foo.dbf", in_memory_file.getvalue())
the_zip.writestr("foo.shx", in_memory_file.getvalue())
the_zip.writestr("foo.prj", in_memory_file.getvalue())
the_zip.close()
files = dict(base_file=SimpleUploadedFile("test_upload.zip", open("test_upload.zip").read()))
form = LayerUploadForm(dict(), files)
self.assertTrue(form.is_valid())
tempdir = form.write_files()[0]
self.assertEquals(set(os.listdir(tempdir)), set(["foo.shp", "foo.shx", "foo.dbf", "foo.prj"]))
os.remove("test_upload.zip")
def testWriteFiles(self):
files = dict(
base_file=SimpleUploadedFile('foo.shp', ' '),
shx_file=SimpleUploadedFile('foo.shx', ' '),
dbf_file=SimpleUploadedFile('foo.dbf', ' '),
prj_file=SimpleUploadedFile('foo.prj', ' '))
form = LayerUploadForm(dict(), files)
self.assertTrue(form.is_valid())
tempdir = form.write_files()[0]
self.assertEquals(set(os.listdir(tempdir)),
set(['foo.shp', 'foo.shx', 'foo.dbf', 'foo.prj']))
the_zip = zipfile.ZipFile('test_upload.zip', 'w')
in_memory_file = StringIO.StringIO()
in_memory_file.write('test')
the_zip.writestr('foo.shp', in_memory_file.getvalue())
the_zip.writestr('foo.dbf', in_memory_file.getvalue())
the_zip.writestr('foo.shx', in_memory_file.getvalue())
the_zip.writestr('foo.prj', in_memory_file.getvalue())
the_zip.close()
files = dict(base_file=SimpleUploadedFile('test_upload.zip', open('test_upload.zip').read()))
form = LayerUploadForm(dict(), files)
self.assertTrue(form.is_valid())
tempdir = form.write_files()[0]
self.assertEquals(set(os.listdir(tempdir)),
set(['foo.shp', 'foo.shx', 'foo.dbf', 'foo.prj']))
os.remove('test_upload.zip')
def testShapefileValidation(self):
files = dict(
base_file=SimpleUploadedFile('foo.shp', ' '),
shx_file=SimpleUploadedFile('foo.shx', ' '),
dbf_file=SimpleUploadedFile('foo.dbf', ' '),
prj_file=SimpleUploadedFile('foo.prj', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(
base_file=SimpleUploadedFile('foo.SHP', ' '),
shx_file=SimpleUploadedFile('foo.SHX', ' '),
dbf_file=SimpleUploadedFile('foo.DBF', ' '),
prj_file=SimpleUploadedFile('foo.PRJ', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(
base_file=SimpleUploadedFile('foo.SHP', ' '),
shx_file=SimpleUploadedFile('foo.shx', ' '),
dbf_file=SimpleUploadedFile('foo.dbf', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(
base_file=SimpleUploadedFile('foo.SHP', ' '),
shx_file=SimpleUploadedFile('foo.shx', ' '),
dbf_file=SimpleUploadedFile('foo.dbf', ' '),
prj_file=SimpleUploadedFile('foo.PRJ', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(
base_file=SimpleUploadedFile('foo.SHP', ' '),
shx_file=SimpleUploadedFile('bar.shx', ' '),
dbf_file=SimpleUploadedFile('bar.dbf', ' '),
prj_file=SimpleUploadedFile('bar.PRJ', ' '))
self.assertFalse(LayerUploadForm(dict(), files).is_valid())
files = dict(
base_file=SimpleUploadedFile('foo.shp', ' '),
dbf_file=SimpleUploadedFile('foo.dbf', ' '),
prj_file=SimpleUploadedFile('foo.PRJ', ' '))
self.assertFalse(LayerUploadForm(dict(), files).is_valid())
files = dict(
base_file=SimpleUploadedFile('foo.txt', ' '),
shx_file=SimpleUploadedFile('foo.shx', ' '),
dbf_file=SimpleUploadedFile('foo.sld', ' '),
prj_file=SimpleUploadedFile('foo.prj', ' '))
self.assertFalse(LayerUploadForm(dict(), files).is_valid())
def testGeoTiffValidation(self):
files = dict(base_file=SimpleUploadedFile('foo.tif', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(base_file=SimpleUploadedFile('foo.TIF', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(base_file=SimpleUploadedFile('foo.tiff', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(base_file=SimpleUploadedFile('foo.TIF', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(base_file=SimpleUploadedFile('foo.geotif', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(base_file=SimpleUploadedFile('foo.GEOTIF', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(base_file=SimpleUploadedFile('foo.geotiff', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(base_file=SimpleUploadedFile('foo.GEOTIF', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
def testASCIIValidation(self):
files = dict(base_file=SimpleUploadedFile('foo.asc', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
files = dict(base_file=SimpleUploadedFile('foo.ASC', ' '))
self.assertTrue(LayerUploadForm(dict(), files).is_valid())
def dataset_append_replace_view(request, layername, template, action_type):
try:
layer = _resolve_dataset(request, layername,
'base.change_resourcebase',
_PERMISSION_MSG_MODIFY)
except PermissionDenied:
return HttpResponse("Not allowed", status=403)
except Exception:
raise Http404("Not found")
if not layer:
raise Http404("Not found")
if request.method == 'GET':
ctx = {
'charsets': CHARSETS,
'resource': layer,
'is_featuretype': layer.is_vector(),
'is_dataset': True,
}
return render(request, template, context=ctx)
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
files, _tmpdir = get_files(base_file)
# validate input source
resource_is_valid = validate_input_source(
layer=layer,
filename=base_file,
files=files,
action_type=action_type)
out = {}
if resource_is_valid:
getattr(resource_manager,
action_type)(layer,
vals={
'files': list(files.values()),
'user': request.user
})
out['success'] = True
out['url'] = layer.get_absolute_url()
# invalidating resource chache
set_geowebcache_invalidate_cache(layer.typename)
except Exception as e:
logger.exception(e)
out['success'] = False
out['errors'] = str(e)
finally:
if tempdir is not None:
shutil.rmtree(tempdir, ignore_errors=True)
if _tmpdir is not None:
shutil.rmtree(_tmpdir, ignore_errors=True)
else:
errormsgs = []
for e in form.errors.values():
errormsgs.append([escape(v) for v in e])
out['errors'] = form.errors
out['errormsgs'] = errormsgs
if out['success']:
status_code = 200
register_event(request, 'change', layer)
else:
status_code = 400
return HttpResponse(json.dumps(out),
content_type='application/json',
status=status_code)
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(request, layername, 'base.change_resourcebase',
_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
ctx = {
'charsets': CHARSETS,
'layer': layer,
'is_featuretype': layer.is_vector(),
'is_layer': True,
}
return render_to_response(template, RequestContext(request, ctx))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
if layer.is_vector() and is_raster(base_file):
out['success'] = False
out['errors'] = _(
"You are attempting to replace a vector layer with a raster."
)
elif (not layer.is_vector()) and is_vector(base_file):
out['success'] = False
out['errors'] = _(
"You are attempting to replace a raster layer with a vector."
)
else:
if check_ogc_backend(geoserver.BACKEND_PACKAGE):
# delete geoserver's store before upload
cat = gs_catalog
cascading_delete(cat, layer.typename)
out['ogc_backend'] = geoserver.BACKEND_PACKAGE
elif check_ogc_backend(qgis_server.BACKEND_PACKAGE):
try:
qgis_layer = QGISServerLayer.objects.get(
layer=layer)
qgis_layer.delete()
except QGISServerLayer.DoesNotExist:
pass
out['ogc_backend'] = qgis_server.BACKEND_PACKAGE
saved_layer = file_upload(
base_file,
name=layer.name,
user=request.user,
overwrite=True,
charset=form.cleaned_data["charset"],
)
out['success'] = True
out['url'] = reverse('layer_detail',
args=[saved_layer.service_typename])
except Exception as e:
logger.exception(e)
tb = traceback.format_exc()
out['success'] = False
out['errors'] = str(tb)
finally:
if tempdir is not None:
shutil.rmtree(tempdir)
else:
errormsgs = []
for e in form.errors.values():
errormsgs.append([escape(v) for v in e])
out['errors'] = form.errors
out['errormsgs'] = errormsgs
if out['success']:
status_code = 200
else:
status_code = 400
return HttpResponse(json.dumps(out),
content_type='application/json',
status=status_code)
def layer_replace(request, layername, template='layers/layer_replace.html'):
layer = _resolve_layer(
request,
layername,
'base.change_resourcebase',
_PERMISSION_MSG_MODIFY)
if request.method == 'GET':
ctx = {
'charsets': CHARSETS,
'layer': layer,
'is_featuretype': layer.is_vector(),
'is_layer': True,
}
return render_to_response(template,
RequestContext(request, ctx))
elif request.method == 'POST':
form = LayerUploadForm(request.POST, request.FILES)
tempdir = None
out = {}
if form.is_valid():
try:
tempdir, base_file = form.write_files()
if layer.is_vector() and is_raster(base_file):
out['success'] = False
out['errors'] = _("You are attempting to replace a vector layer with a raster.")
elif (not layer.is_vector()) and is_vector(base_file):
out['success'] = False
out['errors'] = _("You are attempting to replace a raster layer with a vector.")
else:
try: #^^
main = Main.objects.get(layer=layer) #^^
main_id = main.id #^^
except: #^^
main_id = None #^^
# delete geoserver's store before upload
cat = gs_catalog
cascading_delete(cat, layer.typename)
saved_layer = file_upload(
base_file,
name=layer.name,
user=request.user,
overwrite=True,
charset=form.cleaned_data["charset"],
main_id=main_id, #^^
)
print 'debug file_upload success'
out['success'] = True
out['url'] = reverse(
'layer_detail', args=[
saved_layer.service_typename])
except Exception as e:
out['success'] = False
out['errors'] = str(e)
finally:
if tempdir is not None:
shutil.rmtree(tempdir)
else:
errormsgs = []
for e in form.errors.values():
errormsgs.append([escape(v) for v in e])
out['errors'] = form.errors
out['errormsgs'] = errormsgs
if out['success']:
status_code = 200
else:
status_code = 400
return HttpResponse(
json.dumps(out),
mimetype='application/json',
status=status_code)
