def upload_tiff(dir, region, geoserver_rest_url, workspace, uname, pwd):
headers = {
'Content-type': 'image/tiff',
}
spatial_data_engine = GeoServerSpatialDatasetEngine(
endpoint=geoserver_rest_url, username=uname, password=pwd)
#Check if workspace exists
ws_name = workspace
geoserver_uri = 'www.google.com'
response = spatial_data_engine.list_workspaces()
if response['success']:
workspaces = response['result']
if ws_name not in workspaces:
spatial_data_engine.create_workspace(workspace_id=ws_name,
uri=geoserver_uri)
for file in os.listdir(
dir): #Looping through all the files in the given directory
if file is None:
print "No files. Please check directory and try again."
sys.exit()
data = open(dir + file, 'rb').read() #Read the file
store_name = file.split(
'.')[0] + '_' + region #Creating the store name dynamically
request_url = '{0}workspaces/{1}/coveragestores/{2}/file.geotiff'.format(
geoserver_rest_url, ws_name, store_name) #Creating the rest url
requests.put(request_url,
headers=headers,
data=data,
auth=(uname,
pwd)) #Creating the resource on the geoserver
def addZippedTif2Geoserver(geosvr_url_base, uname, upwd, ws_name, store_name, zippedTif_full_path, res_url):
try:
geosvr_url_full = geosvr_url_base+"/geoserver/rest/"
print "GeoServer REST Full URL: "+geosvr_url_full
coverage_file = zippedTif_full_path
print "Connect to Geoserver"
spatial_dataset_engine = GeoServerSpatialDatasetEngine(endpoint=geosvr_url_full, username=uname, password=upwd)
print "Connected"
response = None
result = spatial_dataset_engine.create_workspace(workspace_id=ws_name, uri=res_url)
if result['success']:
print "Create workspace " + ws_name + " successfully"
else:
print "Create workspace " + ws_name + " failed"
print result
store_id = ws_name + ":" + store_name
result = None
result = spatial_dataset_engine.create_coverage_resource(store_id=store_id, coverage_file=coverage_file, coverage_type='geotiff')
if result['success']:
print "Create store " + store_name + " successfully"
else:
print "Create store " + store_name + " failed"
print result
spatial_dataset_engine.list_layers(debug=True)
return True
except:
print ("addZippedTif2Geoserver() error")
return False
def region_delete(request):
"""
Controller for deleting a region.
"""
if request.is_ajax() and request.method == 'POST':
# get/check information from AJAX request
post_info = request.POST
region_id = post_info.get('region_id')
# initialize session
Session = Grace.get_persistent_store_database('main_db',
as_sessionmaker=True)
session = Session()
try:
# delete region
try:
region = session.query(Region).get(region_id)
except ObjectDeletedError:
session.close()
return JsonResponse(
{'error': "The geoserver to delete does not exist."})
display_name = region.display_name
region_store = ''.join(display_name.split()).lower()
geoserver_id = region.geoserver_id
geoserver = session.query(Geoserver).get(geoserver_id)
geoserver_url = geoserver.url
uname = geoserver.username
pwd = geoserver.password
spatial_dataset_engine = GeoServerSpatialDatasetEngine(
endpoint=geoserver_url, username=uname, password=pwd)
stores = spatial_dataset_engine.list_stores()
for store in stores['result']:
if store.endswith(region_store):
spatial_dataset_engine.delete_store(store,
purge=True,
recurse=True)
FILE_DIR = os.path.join(GRACE_NETCDF_DIR, '')
region_dir = os.path.join(FILE_DIR + region_store, '')
session.delete(region)
session.commit()
session.close()
except IntegrityError:
session.close()
return JsonResponse({
'error':
"This geoserver is connected with a watershed! Must remove connection to delete."
})
finally:
# Delete the temporary directory once the geojson string is created
if region_dir is not None:
if os.path.exists(region_dir):
shutil.rmtree(region_dir)
return JsonResponse({'success': "Region sucessfully deleted!"})
return JsonResponse({'error': "A problem with your request exists."})
def setUp(self):
# Globals
self.debug = False
# Files
self.tests_root = os.path.abspath(os.path.dirname(__file__))
self.files_root = os.path.join(self.tests_root, 'files')
self.shapefile_name = 'test'
self.shapefile_base = os.path.join(self.files_root, 'shapefile',
self.shapefile_name)
# Create Test Engine
self.engine = GeoServerSpatialDatasetEngine(
endpoint=TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT'],
username=TEST_GEOSERVER_DATASET_SERVICE['USERNAME'],
password=TEST_GEOSERVER_DATASET_SERVICE['PASSWORD'])
# Create Test Workspaces
# self.test_resource_workspace = random_string_generator(10)
self.test_resource_workspace = random_string_generator(10)
self.engine.create_workspace(workspace_id=self.test_resource_workspace,
uri=random_string_generator(5))
# Create Test Stores/Resources/Layers
## Shapefile
# Store name
self.test_resource_store = random_string_generator(10)
# Resource and Layer will take the name of the file
self.test_resource_name = self.test_resource_store
self.test_layer_name = self.test_resource_store
# Identifiers of the form 'workspace:item'
self.test_store_identifier = '{0}:{1}'.format(
self.test_resource_workspace, self.test_resource_store)
self.test_resource_identifier = '{0}:{1}'.format(
self.test_resource_workspace, self.test_resource_name)
# Do create shapefile
self.engine.create_shapefile_resource(
self.test_store_identifier,
shapefile_base=self.shapefile_base,
overwrite=True)
## Coverage
# Create Test Style
self.test_style_name = 'point'
# Create Test Layer Groups
self.test_layer_group_name = random_string_generator(10)
self.engine.create_layer_group(
layer_group_id=self.test_layer_group_name,
layers=(self.test_layer_name, ),
styles=(self.test_style_name, ))
# Pause
pause(10)
def get_engine(self):
"""
Retrives GeoServer engine
"""
engine = GeoServerSpatialDatasetEngine(endpoint=self.endpoint,
username=self.username,
password=self.password)
engine.public_endpoint = self.public_endpoint
return engine
def get_engine(self):
"""
Retrives GeoServer engine
"""
engine = GeoServerSpatialDatasetEngine(endpoint=self.endpoint,
username=self.username,
password=self.password)
engine.public_endpoint = self.public_endpoint
return engine
def setUp(self):
# Files
self.tests_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
self.files_root = os.path.join(self.tests_root, 'files')
# GeoServer
self.gs_endpoint = TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT']
self.gs_username = TEST_GEOSERVER_DATASET_SERVICE['USERNAME']
self.gs_password = TEST_GEOSERVER_DATASET_SERVICE['PASSWORD']
self.catalog = GeoServerCatalog(self.gs_endpoint, username=self.gs_username, password=self.gs_password)
# Postgis
self.pg_username = TEST_POSTGIS_SERVICE['USERNAME']
self.pg_password = TEST_POSTGIS_SERVICE['PASSWORD']
self.pg_database = TEST_POSTGIS_SERVICE['DATABASE']
self.pg_table_name = 'points'
self.pg_host = TEST_POSTGIS_SERVICE['HOST']
self.pg_port = TEST_POSTGIS_SERVICE['PORT']
self.pg_url = TEST_POSTGIS_SERVICE['URL']
self.pg_public_url = TEST_POSTGIS_SERVICE['PUBLIC_URL']
# Setup a testing workspace
self.workspace_name = random_string_generator(10)
self.workspace_uri = 'http://www.tethysplatform.org/{}'.format(self.workspace_name)
retries = 5
while retries > 0:
try:
self.catalog.create_workspace(self.workspace_name, self.workspace_uri)
break
except AssertionError as e:
if 'Error persisting' in str(e) and retries > 0:
print("WARNING: FAILED TO PERSIST WORKSPACE.")
retries -= 1
else:
raise
# Setup Postgis database connection
self.public_engine = create_engine(self.pg_public_url)
self.connection = self.public_engine.connect()
self.transaction = self.connection.begin()
# Create GeoServer Engine
self.endpoint = TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT']
self.geoserver_engine = GeoServerSpatialDatasetEngine(endpoint=self.endpoint,
username=TEST_GEOSERVER_DATASET_SERVICE['USERNAME'],
password=TEST_GEOSERVER_DATASET_SERVICE['PASSWORD'])
self.geometry_column = 'geometry'
self.geometry_type = 'Point'
self.srid = 4326
def upload_files_to_geoserver(filepaths, geoserver_uri,
geoserver_rest_endpoint_url, workspace, username,
password):
if type(geoserver_uri) is unicode:
geoserver_uri = str(geoserver_uri)
if type(geoserver_rest_endpoint_url) is unicode:
geoserver_rest_endpoint_url = str(geoserver_rest_endpoint_url)
if type(workspace) is unicode:
workspace = str(workspace)
if type(username) is unicode:
username = str(username)
if type(password) is unicode:
password = str(password)
geoserver_engine = GeoServerSpatialDatasetEngine(
endpoint=geoserver_rest_endpoint_url,
username=username,
password=password)
#create workspace
response = geoserver_engine.list_workspaces()
if response['success']:
workspaces = response['result']
if workspace not in workspaces:
print "I did something"
response = geoserver_engine.create_workspace(workspace_id=workspace,
uri=geoserver_uri)
#upload to geoserver
for filename in filepaths:
store = filename.split("\\")[-1]
store_id = workspace + ':' + store
print 'uploading ' + filename + ' to store ' + store_id + '...'
response = geoserver_engine.create_coverage_resource(
store_id=store_id,
coverage_file=filename,
coverage_type='worldimage',
overwrite=True,
debug=True)
return
def upload_files_to_geoserver(filepaths, geoserver_uri, geoserver_rest_endpoint_url, workspace, username, password):
if type(geoserver_uri) is unicode:
geoserver_uri = str(geoserver_uri)
if type(geoserver_rest_endpoint_url) is unicode:
geoserver_rest_endpoint_url = str(geoserver_rest_endpoint_url)
if type(workspace) is unicode:
workspace = str(workspace)
if type(username) is unicode:
username = str(username)
if type(password) is unicode:
password = str(password)
geoserver_engine = GeoServerSpatialDatasetEngine(endpoint=geoserver_rest_endpoint_url,
username=username, password=password)
#create workspace
response = geoserver_engine.list_workspaces()
if response['success']:
workspaces = response['result']
if workspace not in workspaces:
print "I did something"
response = geoserver_engine.create_workspace(workspace_id=workspace,uri=geoserver_uri)
#upload to geoserver
for filename in filepaths:
store = filename.split("\\")[-1]
store_id = workspace + ':' + store
print 'uploading ' + filename + ' to store ' + store_id + '...'
response = geoserver_engine.create_coverage_resource(store_id=store_id,
coverage_file = filename,
coverage_type='worldimage',
overwrite=True,
debug=True)
return
def geoserver_update(request):
"""
Controller for updating a geoserver.
"""
if request.is_ajax() and request.method == 'POST':
# get/check information from AJAX request
post_info = request.POST
geoserver_id = post_info.get('geoserver_id')
geoserver_name = post_info.get('geoserver_name')
geoserver_url = post_info.get('geoserver_url')
geoserver_username = post_info.get('geoserver_username')
geoserver_password = post_info.get('geoserver_password')
# check data
if not geoserver_id or not geoserver_name or not geoserver_url or not \
geoserver_username or not geoserver_password:
return JsonResponse({'error': "Missing input data."})
# make sure id is id
try:
int(geoserver_id)
except ValueError:
return JsonResponse({'error': 'Geoserver id is faulty.'})
Session = Grace.get_persistent_store_database('main_db',
as_sessionmaker=True)
session = Session()
geoserver = session.query(Geoserver).get(geoserver_id)
try:
spatial_dataset_engine = GeoServerSpatialDatasetEngine(
endpoint=geoserver_url,
username=geoserver_username,
password=geoserver_password)
layer_list = spatial_dataset_engine.list_layers(debug=True)
if layer_list:
geoserver.geoserver_name = geoserver_name
geoserver.geoserver_url = geoserver_url
geoserver.geoserver_username = geoserver_username
geoserver.geoserver_password = geoserver_password
session.commit()
session.close()
return JsonResponse(
{'success': "Geoserver sucessfully updated!"})
except:
return JsonResponse(
{'error': "A problem with your request exists."})
def addZippedShp2Geoserver(geosvr_url_base, uname, upwd, ws_name, store_name, zippedTif_full_path, res_url):
try:
# Specifying the full REST url
geosvr_url_full = geosvr_url_base+"/geoserver/rest/"
print "GeoServer REST Full URL: "+ geosvr_url_full
print "Connect to Geoserver"
# First get the engine
spatial_dataset_engine = GeoServerSpatialDatasetEngine(endpoint=geosvr_url_full, username=uname, password=upwd)
print "Connected"
response = None
# Creating the workspace
result = spatial_dataset_engine.create_workspace(workspace_id=ws_name, uri=res_url)
if result['success']:
print "Create workspace " + ws_name + " successfully"
else:
print "Create workspace " + ws_name + " failed"
print result
store_id = ws_name+":"+store_name
# Path to the shapefile base
coverage_file = zippedTif_full_path
print zippedTif_full_path
# Creating a workspace for registering a shapefile in the geoserver
result = spatial_dataset_engine.create_shapefile_resource(store_id=store_id, shapefile_base=coverage_file)
# Check if it was successful
if result['success']:
print "Create store " + store_name + " successfully"
else:
print "Create store " + store_name + " failed"
print result
# Debugging
spatial_dataset_engine.list_layers(debug=True)
return True
except:
print ("addZippedShp2Geoserver() error")
raise Exception("addZippedShp2Geoserver() error")
def get_engine(self):
"""
Retrieves spatial dataset engine
"""
engine = None
if self.engine == self.GEOSERVER:
engine = GeoServerSpatialDatasetEngine(endpoint=self.endpoint,
username=self.username,
password=self.password)
engine.public_endpoint = self.public_endpoint
elif self.engine == self.THREDDS:
if self.username and self.password:
session_manager.set_session_options(auth=(str(self.username),
str(self.password)))
catalog_endpoint = str(self.endpoint).rstrip('/') + '/catalog.xml'
engine = TDSCatalog(str(catalog_endpoint))
return engine
def setUp(self):
# Globals
self.debug = False
# Files
self.tests_root = os.path.abspath(os.path.dirname(__file__))
self.files_root = os.path.join(self.tests_root, 'files')
self.shapefile_name = 'test'
self.shapefile_base = os.path.join(self.files_root, 'shapefile', self.shapefile_name)
# Create Test Engine
self.engine = GeoServerSpatialDatasetEngine(endpoint=TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT'],
username=TEST_GEOSERVER_DATASET_SERVICE['USERNAME'],
password=TEST_GEOSERVER_DATASET_SERVICE['PASSWORD'])
# Create Test Workspaces
# self.test_resource_workspace = random_string_generator(10)
self.test_resource_workspace = random_string_generator(10)
self.engine.create_workspace(workspace_id=self.test_resource_workspace, uri=random_string_generator(5))
# Create Test Stores/Resources/Layers
## Shapefile
# Store name
self.test_resource_store = random_string_generator(10)
# Resource and Layer will take the name of the file
self.test_resource_name = self.test_resource_store
self.test_layer_name = self.test_resource_store
# Identifiers of the form 'workspace:item'
self.test_store_identifier = '{0}:{1}'.format(self.test_resource_workspace, self.test_resource_store)
self.test_resource_identifier = '{0}:{1}'.format(self.test_resource_workspace, self.test_resource_name)
# Do create shapefile
self.engine.create_shapefile_resource(self.test_store_identifier, shapefile_base=self.shapefile_base,
overwrite=True)
## Coverage
# Create Test Style
self.test_style_name = 'point'
# Create Test Layer Groups
self.test_layer_group_name = random_string_generator(10)
self.engine.create_layer_group(layer_group_id=self.test_layer_group_name,
layers=(self.test_layer_name,),
styles=(self.test_style_name,))
# Pause
pause(10)
def geoserver_add(request):
response = {}
if request.is_ajax() and request.method == 'POST':
info = request.POST
geoserver_name = info.get('geoserver_name')
geoserver_url = info.get('geoserver_url')
geoserver_username = info.get('geoserver_username')
geoserver_password = info.get('geoserver_password')
try:
spatial_dataset_engine = GeoServerSpatialDatasetEngine(
endpoint=geoserver_url,
username=geoserver_username,
password=geoserver_password)
layer_list = spatial_dataset_engine.list_layers(debug=True)
if layer_list:
Session = Grace.get_persistent_store_database(
'main_db', as_sessionmaker=True)
session = Session()
geoserver = Geoserver(name=geoserver_name,
url=geoserver_url,
username=geoserver_username,
password=geoserver_password)
session.add(geoserver)
session.commit()
session.close()
response = {"data": geoserver_name, "success": "Success"}
except:
response = {
"error":
"Error processing the Geoserver URL. Please check the url,username and password."
}
return JsonResponse(response)
def delete_old_watershed_geoserver_files(watershed):
"""
Removes old watershed geoserver files from system
"""
engine = GeoServerSpatialDatasetEngine(
endpoint="%s/rest" % watershed.geoserver.url,
username=watershed.geoserver.username,
password=watershed.geoserver.password)
if watershed.geoserver_drainage_line_uploaded:
purge_remove_geoserver_layer(watershed.geoserver_drainage_line_layer,
engine)
if watershed.geoserver_catchment_uploaded:
purge_remove_geoserver_layer(watershed.geoserver_catchment_layer,
engine)
if watershed.geoserver_gage_uploaded:
purge_remove_geoserver_layer(watershed.geoserver_gage_layer, engine)
if watershed.geoserver_ahps_station_uploaded:
purge_remove_geoserver_layer(watershed.geoserver_ahps_station_layer,
engine)
def addZippedShapefile2Geoserver(geosvr_url_base, uname, upwd, ws_name,
store_name, zippedTif_full_path, res_url):
try:
geosvr_url_full = geosvr_url_base + "/geoserver/rest/"
logger.debug("GeoServer REST Full URL: " + geosvr_url_full)
coverage_file = zippedTif_full_path
logger.debug("Connect to Geoserver")
spatial_dataset_engine = GeoServerSpatialDatasetEngine(
endpoint=geosvr_url_full, username=uname, password=upwd)
logger.debug("Connected")
response = None
result = spatial_dataset_engine.create_workspace(workspace_id=ws_name,
uri=res_url)
if result['success']:
logger.debug("Create workspace " + ws_name + " successfully")
else:
logger.debug("Create workspace " + ws_name + " failed")
logger.debug(result)
store_id = ws_name + ":" + store_name
result = None
result = spatial_dataset_engine.create_shapefile_resource(
store_id=store_id, shapefile_zip=coverage_file)
if result['success']:
logger.debug("Create store " + store_name + " successfully")
else:
logger.debug("Create store " + store_name + " failed")
logger.debug(result)
spatial_dataset_engine.list_layers(debug=True)
return True
except:
logger.exception("addZippedTif2Geoserver() error")
return False
def delete(request):
list = {}
session = SessionMaker()
# Query DB for hydroservers
if request.is_ajax() and request.method == 'POST':
title = request.POST['server']
geo_url = geo_url_base + "/geoserver/rest/"
spatial_dataset_engine = GeoServerSpatialDatasetEngine(
endpoint=geo_url, username=geo_user, password=geo_pw)
store_string = "catalog" + ":" + str(title)
spatial_dataset_engine.delete_layer(layer_id=store_string, purge=True)
spatial_dataset_engine.delete_store(store_id=store_string, purge=True)
hydroservers = session.query(Catalog).filter(
Catalog.title == title).delete(synchronize_session='evaluate')
session.commit()
session.close()
# spatial_dataset_engine.delete_store(title,purge=True,debug=True)
list["title"] = title
return JsonResponse(list)
class TestGeoServerDatasetEngine(unittest.TestCase):
def setUp(self):
# Globals
self.debug = False
# Files
self.tests_root = os.path.abspath(os.path.dirname(__file__))
self.files_root = os.path.join(self.tests_root, 'files')
self.shapefile_name = 'test'
self.shapefile_base = os.path.join(self.files_root, 'shapefile',
self.shapefile_name)
# Create Test Engine
self.engine = GeoServerSpatialDatasetEngine(
endpoint=TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT'],
username=TEST_GEOSERVER_DATASET_SERVICE['USERNAME'],
password=TEST_GEOSERVER_DATASET_SERVICE['PASSWORD'])
# Create Test Workspaces
# self.test_resource_workspace = random_string_generator(10)
self.test_resource_workspace = random_string_generator(10)
self.engine.create_workspace(workspace_id=self.test_resource_workspace,
uri=random_string_generator(5))
# Create Test Stores/Resources/Layers
## Shapefile
# Store name
self.test_resource_store = random_string_generator(10)
# Resource and Layer will take the name of the file
self.test_resource_name = self.test_resource_store
self.test_layer_name = self.test_resource_store
# Identifiers of the form 'workspace:item'
self.test_store_identifier = '{0}:{1}'.format(
self.test_resource_workspace, self.test_resource_store)
self.test_resource_identifier = '{0}:{1}'.format(
self.test_resource_workspace, self.test_resource_name)
# Do create shapefile
self.engine.create_shapefile_resource(
self.test_store_identifier,
shapefile_base=self.shapefile_base,
overwrite=True)
## Coverage
# Create Test Style
self.test_style_name = 'point'
# Create Test Layer Groups
self.test_layer_group_name = random_string_generator(10)
self.engine.create_layer_group(
layer_group_id=self.test_layer_group_name,
layers=(self.test_layer_name, ),
styles=(self.test_style_name, ))
# Pause
pause(10)
def tearDown(self):
# Delete test layer groups
self.engine.delete_layer_group(
layer_group_id=self.test_layer_group_name)
# Delete test resources & layers
self.engine.delete_resource(self.test_resource_identifier,
recurse=True)
# Delete stores
self.engine.delete_store(self.test_store_identifier)
# Delete test workspace
self.engine.delete_workspace(self.test_resource_workspace)
def assert_valid_response_object(self, response_object):
# Response object should be a dictionary with the keys 'success' and either 'result' if success is True
# or 'error' if success is False
self.assertIsInstance(response_object, dict)
self.assertIn('success', response_object)
if isinstance(response_object, dict) and 'success' in response_object:
if response_object['success'] is True:
self.assertIn('result', response_object)
elif response_object['success'] is False:
self.assertIn('error', response_object)
def test_list_resources(self):
pause(10)
# Execute
response = self.engine.list_resources(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer listed
self.assertIn(self.test_resource_name, result)
def test_list_resources_with_properties(self):
# Execute
response = self.engine.list_resources(with_properties=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_resource_in = False
for r in result:
if r['name'] == self.test_resource_name:
test_resource_in = True
break
self.assertTrue(test_resource_in)
def test_list_layers(self):
# Execute
response = self.engine.list_layers(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer listed
self.assertIn(self.test_layer_name, result)
def test_list_layers_with_properties(self):
# Execute
response = self.engine.list_layers(with_properties=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_layer_in = False
for r in result:
if r['name'] == self.test_layer_name:
test_layer_in = True
break
self.assertTrue(test_layer_in)
def test_list_layer_groups(self):
# Execute
response = self.engine.list_layer_groups(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer group listed
self.assertIn(self.test_layer_group_name, result)
def test_list_layer_groups_with_properties(self):
# Execute
response = self.engine.list_layer_groups(with_properties=True,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_layer_group_in = False
for r in result:
if r['name'] == self.test_layer_group_name:
test_layer_group_in = True
break
self.assertTrue(test_layer_group_in)
def test_list_workspaces(self):
pass
def test_list_stores(self):
pass
def test_list_styles(self):
pass
def test_get_resource(self):
# Execute
response = self.engine.get_resource(
resource_id=self.test_resource_name, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('workspace', result)
self.assertEqual(result['workspace'], self.test_resource_workspace)
def test_get_resource_with_workspace(self):
# Execute
response = self.engine.get_resource(
resource_id=self.test_resource_identifier, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertIn('workspace', result)
self.assertEqual(result['name'], self.test_resource_name)
self.assertEqual(result['workspace'], self.test_resource_workspace)
def test_get_resource_with_store(self):
# Execute
response = self.engine.get_resource(
resource_id=self.test_resource_name,
store=self.test_resource_store,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertIn('store', result)
self.assertEqual(result['name'], self.test_resource_name)
self.assertEqual(result['store'], self.test_resource_store)
def test_get_resource_multiple_with_name(self):
pass
def test_get_layer(self):
# Execute
response = self.engine.get_layer(layer_id=self.test_layer_name,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertEqual(result['name'], self.test_layer_name)
def test_get_layer_group(self):
# Execute
response = self.engine.get_layer_group(
layer_group_id=self.test_layer_group_name, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertEqual(result['name'], self.test_layer_group_name)
def test_get_store(self):
pass
def test_get_workspace(self):
pass
def test_get_style(self):
pass
def test_update_resource(self):
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(
resource_id=self.test_resource_name,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(
resource_id=self.test_resource_name, debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_resource_workspace(self):
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(
resource_id=self.test_resource_identifier,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(
resource_id=self.test_resource_identifier, debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_resource_store(self):
pause(10)
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(
resource_id=self.test_resource_name,
store=self.test_resource_store,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(
resource_id=self.test_resource_name,
store=self.test_resource_store,
debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_layer(self):
# Get original
old_response = self.engine.get_layer(layer_id=self.test_layer_name)
# Update
new_default_style = self.test_style_name
response = self.engine.update_layer(layer_id=self.test_layer_name,
default_style=new_default_style,
debug=self.debug)
# Update should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
old_result = old_response['result']
result = response['result']
self.assertEqual(result['default_style'], new_default_style)
self.assertNotEqual(old_result['default_style'],
result['default_style'])
def test_update_layer_group(self):
pass
def test_delete_resource(self):
# Must delete layer group and layer first
self.engine.delete_layer_group(
layer_group_id=self.test_layer_group_name)
self.engine.delete_layer(layer_id=self.test_layer_name)
# Do delete
response = self.engine.delete_resource(
resource_id=self.test_resource_identifier)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_resource_belongs_to_layer(self):
# Do delete without deleting layer group and layer
response = self.engine.delete_resource(
resource_id=self.test_resource_identifier)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_resource_recurse(self):
# Force delete with recurse
response = self.engine.delete_resource(
resource_id=self.test_resource_identifier, recurse=True)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_resource_does_not_exist(self):
# Do delete
response = self.engine.delete_resource(resource_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer(self):
# Delete layer group first
self.engine.delete_layer_group(
layer_group_id=self.test_layer_group_name)
# Do delete
response = self.engine.delete_layer(layer_id=self.test_layer_name)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_belongs_to_group(self):
# Do delete without deleting layer group
response = self.engine.delete_layer(layer_id=self.test_layer_name)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer_recurse(self):
# Force delete with recurse
response = self.engine.delete_layer(layer_id=self.test_layer_name,
recurse=True)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_does_not_exist(self):
# Delete layer group first
self.engine.delete_layer_group(
layer_group_id=self.test_layer_group_name)
# Do delete
response = self.engine.delete_layer(layer_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer_group(self):
# Do delete
response = self.engine.delete_layer_group(
layer_group_id=self.test_layer_group_name)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_group_does_not_exist(self):
# Do delete
response = self.engine.delete_layer_group(layer_group_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_workspace(self):
pass
def test_delete_store(self):
pass
def test_delete_style(self):
pass
def test_create_layer_group(self):
# Do create
name = random_string_generator(10)
layers = (self.test_layer_name, )
styles = (self.test_style_name, )
response = self.engine.create_layer_group(layer_group_id=name,
layers=layers,
styles=styles)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
# Validate
result = response['result']
self.assertEqual(result['name'], name)
self.assertEqual(result['layers'], layers)
self.assertEqual(result['styles'], [])
# Clean up
self.engine.delete_layer_group(layer_group_id=name)
def test_create_layer_group_mismatch_layers_styles(self):
# Do create with differing number of styles and layers
name = random_string_generator(10)
layers = (self.test_layer_name, )
styles = (self.test_style_name, self.test_style_name)
response = self.engine.create_layer_group(layer_group_id=name,
layers=layers,
styles=styles)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_create_shapefile_resource(self):
self.assertTrue(False)
def test_create_coverage_resource(self):
self.assertTrue(False)
def test_create_workspace(self):
self.assertTrue(False)
def test_create_style(self):
self.assertTrue(False)
def test_create_sql_view(self):
self.assertTrue(False)
#-------------------------------------------------------------------------------
# Name: module1
# Purpose:
#
# Author: mscott90
#
# Created: 21/02/2014
# Copyright: (c) mscott90 2014
# Licence: <your licence>
#-------------------------------------------------------------------------------
import shutil, sys, re, subprocess, time, os
from tethys_dataset_services.engines import GeoServerSpatialDatasetEngine
from zipfile import ZipFile
geoserver_engine = GeoServerSpatialDatasetEngine(endpoint='http://ciwmap.chpc.utah.edu:8080/geoserver/rest', username='******', password='******')
GSSHA_EXE = 'gssha.exe'
def main(prj, job_id):
os.chdir('gssha_provo_flood')
runGSSHA(prj)
reformat(prj, job_id)
zip_floodmap(job_id)
upload_to_geoserver(job_id)
os.chdir('..')
def runGSSHA(prjFile):
#outFile = "run.out"
#out = open(outFile, 'w')
process = subprocess.Popen([GSSHA_EXE, prjFile])
process.wait()
def genShapeFile(input,title,geo_url,username,password,hs_url):
try:
file_name = 'hs_sites'
temp_dir = tempfile.mkdtemp()
file_location = temp_dir+"/"+file_name
w = sf.Writer(sf.POINT)
w.field('sitename')
w.field('sitecode')
w.field('network')
w.field('service')
w.field('url','C',200)
# w.field('elevation')
for item in input:
w.point(float(item['longitude']),float(item['latitude']))
site_name = item['sitename']
site_name.decode("utf-8")
w.record(item['sitename'],item['sitecode'],item['network'],item['service'],hs_url, 'Point')
w.save(file_location)
prj = open("%s.prj" % file_location, "w")
epsg = 'GEOGCS["WGS84",DATUM["WGS_1984",SPHEROID["WGS84",6378137,298.257223563,AUTHORITY["EPSG","7030"]],AUTHORITY["EPSG","6326"]],PRIMEM["Greenwich",0,AUTHORITY["EPSG","8901"]],UNIT["degree",0.01745329251994328,AUTHORITY["EPSG","9122"]],AUTHORITY["EPSG","4326"]]'
prj.write(epsg)
prj.close()
file_list = os.listdir(temp_dir)
zip_file_full_path = temp_dir + "/" + "shapefile.zip"
with zipfile.ZipFile(zip_file_full_path, 'a') as myzip:
for fn in file_list:
shapefile_fp = temp_dir + "/"+ fn # tif full path
new_file_name = title + os.path.splitext(fn)[1]
myzip.write(shapefile_fp, arcname=new_file_name)
#Connecting to geoserver
spatial_dataset_engine = GeoServerSpatialDatasetEngine(endpoint=geo_url, username=username, password=password)
layer_metadata = {}
response = None
ws_name = "catalog"
result = spatial_dataset_engine.create_workspace(workspace_id=ws_name, uri="www.servir.org")
if result['success']:
print "Created workspace " + ws_name + " successfully"
else:
print "Creating workspace " + ws_name + " failed"
#print result
store_id = ws_name + ":" + title
result = None
result = spatial_dataset_engine.create_shapefile_resource(store_id=store_id, shapefile_zip=zip_file_full_path)
if result['success']:
print "Created store " + title + " successfully"
else:
print "Creating store " + title + " failed"
#find the bbox area
wms_rest_url = '{}workspaces/{}/datastores/{}/featuretypes/{}.json'.format(geo_url,ws_name,title,title)
print wms_rest_url
r = requests.get(wms_rest_url, auth=(username,password))
if r.status_code != 200:
print 'The Geoserver appears to be down.'
else:
json = r.json()
extents = json['featureType']['latLonBoundingBox']
# wms_response = urllib2.urlopen(wms_rest_url)
# wms_data = wms_response.read()
# print wms_data
layer_metadata["layer"] = store_id
layer_metadata["extents"] = extents
return layer_metadata
except:
return False
finally:
if temp_dir is not None:
if os.path.exists(temp_dir):
shutil.rmtree(temp_dir)
class GeoServerDatasetEngineEnd2EndTests(unittest.TestCase):
def setUp(self):
# Files
self.tests_root = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
self.files_root = os.path.join(self.tests_root, 'files')
# GeoServer
self.gs_endpoint = TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT']
self.gs_username = TEST_GEOSERVER_DATASET_SERVICE['USERNAME']
self.gs_password = TEST_GEOSERVER_DATASET_SERVICE['PASSWORD']
self.catalog = GeoServerCatalog(self.gs_endpoint, username=self.gs_username, password=self.gs_password)
# Postgis
self.pg_username = TEST_POSTGIS_SERVICE['USERNAME']
self.pg_password = TEST_POSTGIS_SERVICE['PASSWORD']
self.pg_database = TEST_POSTGIS_SERVICE['DATABASE']
self.pg_table_name = 'points'
self.pg_host = TEST_POSTGIS_SERVICE['HOST']
self.pg_port = TEST_POSTGIS_SERVICE['PORT']
self.pg_url = TEST_POSTGIS_SERVICE['URL']
self.pg_public_url = TEST_POSTGIS_SERVICE['PUBLIC_URL']
# Setup a testing workspace
self.workspace_name = random_string_generator(10)
self.workspace_uri = 'http://www.tethysplatform.org/{}'.format(self.workspace_name)
retries = 5
while retries > 0:
try:
self.catalog.create_workspace(self.workspace_name, self.workspace_uri)
break
except AssertionError as e:
if 'Error persisting' in str(e) and retries > 0:
print("WARNING: FAILED TO PERSIST WORKSPACE.")
retries -= 1
else:
raise
# Setup Postgis database connection
self.public_engine = create_engine(self.pg_public_url)
self.connection = self.public_engine.connect()
self.transaction = self.connection.begin()
# Create GeoServer Engine
self.endpoint = TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT']
self.geoserver_engine = GeoServerSpatialDatasetEngine(endpoint=self.endpoint,
username=TEST_GEOSERVER_DATASET_SERVICE['USERNAME'],
password=TEST_GEOSERVER_DATASET_SERVICE['PASSWORD'])
self.geometry_column = 'geometry'
self.geometry_type = 'Point'
self.srid = 4326
def assert_valid_response_object(self, response_object):
# Response object should be a dictionary with the keys 'success' and either 'result' if success is True
# or 'error' if success is False
self.assertIsInstance(response_object, dict)
self.assertIn('success', response_object)
if isinstance(response_object, dict) and 'success' in response_object:
if response_object['success'] is True:
self.assertIn('result', response_object)
elif response_object['success'] is False:
self.assertIn('error', response_object)
def tearDown(self):
# Clean up GeoServer
workspace = self.catalog.get_workspace(self.workspace_name)
self.catalog.delete(workspace, recurse=True, purge=True)
# Clean up Postgis database
self.transaction.rollback()
self.connection.close()
self.public_engine.dispose()
def setup_postgis_table(self):
"""
Creates table in the database named "points" with two entries. The table has three columns:
"id", "name", and "geometry." Use this table for the tests that require a database.
"""
# Clean up
delete_sql = "DROP TABLE IF EXISTS {table}".\
format(table=self.pg_table_name)
self.connection.execute(delete_sql)
# Create table
geom_table_sql = "CREATE TABLE IF NOT EXISTS {table} (" \
"id integer CONSTRAINT points_primary_key PRIMARY KEY, " \
"name varchar(20)" \
"); " \
"SELECT AddGeometryColumn('public', '{table}', 'geometry', 4326, 'POINT', 2);". \
format(table=self.pg_table_name)
self.connection.execute(geom_table_sql)
insert_sql = "INSERT INTO {table} VALUES ({id}, '{name}', ST_GeomFromText('POINT({lon} {lat})', 4326));"
rows = [
{"id": 1, "name": "Aquaveo", "lat": 40.276039, "lon": -111.651120},
{"id": 2, "name": "BYU", "lat": 40.252335, "lon": -111.649326},
]
for r in rows:
sql = insert_sql.format(
table=self.pg_table_name,
id=r['id'],
name=r['name'],
lat=r['lat'],
lon=r['lon']
)
self.connection.execute(sql)
self.transaction.commit()
def test_create_shapefile_resource_base(self):
# call methods: create_shapefile_resource, list_resources, get_resource, delete_resource
# TEST create shapefile
# Setup
filename = 'test'
shapefile_name = os.path.join(self.files_root, 'shapefile', filename)
workspace = self.workspace_name
store_id = random_string_generator(10)
store_id_name = '{}:{}'.format(workspace, store_id)
# store_id_name = store_id
# Execute
response = self.geoserver_engine.create_shapefile_resource(store_id=store_id_name,
shapefile_base=shapefile_name,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Should succeed
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn(store_id, r['name'])
self.assertIn(store_id, r['store'])
# TEST list_resources
# Execute
response = self.geoserver_engine.list_resources()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# layer listed
self.assertIn(store_id, result)
# TEST get_resources
# Execute
# Geoserver uses the store_id as the layer/resource name (not the filename)
resource_id_name = '{}:{}'.format(workspace, store_id)
response = self.geoserver_engine.get_resource(resource_id=resource_id_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertEquals(store_id, r['name'])
self.assertIn(store_id, r['wfs']['shapefile'])
# TEST delete_resource
# Execute
# This case the resource id is the same as the store id.
response = self.geoserver_engine.delete_resource(resource_id=resource_id_name,
store_id=store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
# TODO: delete_resource is returning a 403 error: not authorized.
# self.assertTrue(response['success'])
def test_create_shapefile_resource_zip(self):
# call methods: create_shapefile_resource, list_layers, get_layer, delete_layer
# TEST create_shapefile_resource
# Test1.zip
# Setup
shapefile_zip = os.path.join(self.files_root, 'shapefile', "test1.zip")
shapefile = "test1"
workspace = self.workspace_name
store_id = random_string_generator(10)
store_id_name = '{}:{}'.format(workspace, store_id)
# Execute
response = self.geoserver_engine.create_shapefile_resource(store_id=store_id_name,
shapefile_zip=shapefile_zip,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Should succeed
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
filename = os.path.splitext(os.path.basename(shapefile_zip))[0]
self.assertIsInstance(r, dict)
self.assertIn(filename, r['name'])
self.assertIn(store_id, r['store'])
# TEST list_layers test
# Execute
response = self.geoserver_engine.list_layers()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# Get the last item from result
layer_id = '{}:{}'.format(workspace, shapefile)
# TEST get layers test
# Execute
response = self.geoserver_engine.get_layer(layer_id=layer_id,
store_id=store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn(filename, r['name'])
self.assertIn(self.workspace_name, r['name'])
# TEST delete_layer
self.geoserver_engine.delete_layer(layer_id=layer_id,
store_id=store_id)
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_shapefile_resource_upload(self):
# call methods: create_shapefile_resource, list_stores, get_store, delete_store
# TEST create_shapefile_resource
# Use in memory file list: test.shp and friends
# Setup
shapefile_cst = os.path.join(self.files_root, 'shapefile', 'test.cst')
shapefile_dbf = os.path.join(self.files_root, 'shapefile', 'test.dbf')
shapefile_prj = os.path.join(self.files_root, 'shapefile', 'test.prj')
shapefile_shp = os.path.join(self.files_root, 'shapefile', 'test.shp')
shapefile_shx = os.path.join(self.files_root, 'shapefile', 'test.shx')
# Workspace is given
store_rand = random_string_generator(10)
store_id = '{}:{}'.format(self.workspace_name, store_rand)
with open(shapefile_cst, 'rb') as cst_upload,\
open(shapefile_dbf, 'rb') as dbf_upload,\
open(shapefile_prj, 'rb') as prj_upload,\
open(shapefile_shp, 'rb') as shp_upload,\
open(shapefile_shx, 'rb') as shx_upload:
upload_list = [cst_upload, dbf_upload, prj_upload, shp_upload, shx_upload]
response = self.geoserver_engine.create_shapefile_resource(store_id=store_id,
shapefile_upload=upload_list,
overwrite=True)
# Should succeed
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn(store_rand, r['name'])
self.assertIn(store_rand, r['store'])
# TEST list_stores
# Execute
response = self.geoserver_engine.list_stores()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# layer group listed
self.assertIn(store_rand, result)
# TEST get store
# Execute
response = self.geoserver_engine.get_store(store_id=store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(r['name'], store_rand)
self.assertIn('workspace', r)
self.assertEqual(self.workspace_name, r['workspace'])
# TEST delete_store
response = self.geoserver_engine.delete_store(store_id=store_id, purge=True, recurse=True)
# Failure Check
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_coverage_resource_arcgrid(self):
# call methods: create_coverage_resource, list_resources, get_resource, delete_resource
# TEST create_coverage_resource
# precip30min.zip
store_name = random_string_generator(10)
expected_store_id = '{}:{}'.format(self.workspace_name, store_name)
expected_coverage_type = 'arcgrid'
coverage_file_name = 'precip30min.zip'
coverage_name = coverage_file_name.split('.')[0]
coverage_file = os.path.join(self.files_root, "arc_sample", coverage_file_name)
with open(coverage_file, 'rb') as coverage_upload:
# Execute
response = self.geoserver_engine.create_coverage_resource(store_id=expected_store_id,
coverage_type=expected_coverage_type,
coverage_upload=coverage_upload,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Values
self.assertEqual(coverage_name, r['name'])
self.assertEqual(self.workspace_name, r['workspace'])
# TEST list_resources
# Execute
response = self.geoserver_engine.list_resources()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# layer listed
self.assertIn(coverage_name, result)
# TEST get_resource
# Execute
resource_id = '{}:{}'.format(self.workspace_name, coverage_name)
response = self.geoserver_engine.get_resource(resource_id=resource_id,
store_id=store_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
self.assertIn('ArcGrid', r['keywords'])
self.assertEqual(coverage_name, r['title'])
self.assertEqual('coverage', r['resource_type'])
# delete_resource
# TODO: delete_resource is returning a 403 error: not authorized.
# Execute
resource_id = '{}:{}'.format(self.workspace_name, coverage_name)
response = self.geoserver_engine.delete_resource(resource_id=resource_id,
store_id=store_name)
# # Validate response object
self.assert_valid_response_object(response)
# # Success
# self.assertTrue(response['success'])
def test_create_coverage_resource_grassgrid(self):
# call methods: create_coverage_resource, list_layers, get_layer, delete_layer
# TEST create_coverage resource
# my_grass.zip
store_name = random_string_generator(10)
expected_store_id = '{}:{}'.format(self.workspace_name, store_name)
expected_coverage_type = 'grassgrid'
coverage_file_name = 'my_grass.zip'
coverage_name = coverage_file_name.split('.')[0]
coverage_file = os.path.join(self.files_root, "grass_ascii", coverage_file_name)
# Execute
response = self.geoserver_engine.create_coverage_resource(store_id=expected_store_id,
coverage_type=expected_coverage_type,
coverage_file=coverage_file,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Tests
self.assertIn(coverage_name, r['name'])
self.assertEqual(self.workspace_name, r['workspace'])
# TEST list_layers
# Execute
response = self.geoserver_engine.list_layers()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# Check if layer is in list
self.assertIn(coverage_name, result)
# TEST get_layer
# Execute
layer_id = '{}:{}'.format(self.workspace_name, coverage_name)
response = self.geoserver_engine.get_layer(layer_id=layer_id,
store_id=store_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn(store_name, r['store'])
self.assertIn(self.workspace_name, r['name'])
# TEST delete_layer
self.geoserver_engine.delete_layer(layer_id=layer_id,
store_id=store_name)
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_coverage_resource_geotiff(self):
# adem.tif
# call methods: create_coverage_resource, list_stores, get_store, delete_store
# TEST create_coverage_resource
store_name = random_string_generator(10)
expected_store_id = '{}:{}'.format(self.workspace_name, store_name)
expected_coverage_type = 'geotiff'
coverage_file_name = 'adem.tif'
coverage_name = coverage_file_name.split('.')[0]
coverage_file = os.path.join(self.files_root, coverage_file_name)
with open(coverage_file, 'rb') as coverage_upload:
# Execute
response = self.geoserver_engine.create_coverage_resource(store_id=expected_store_id,
coverage_type=expected_coverage_type,
coverage_upload=coverage_upload,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Values
self.assertEqual(coverage_name, r['name'])
self.assertEqual(self.workspace_name, r['workspace'])
# TEST list_stores
# Execute
response = self.geoserver_engine.list_stores()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# TEST layer group listed
self.assertIn(store_name, result)
# TEST get store
# Execute
response = self.geoserver_engine.get_store(store_id=expected_store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(r['name'], store_name)
self.assertIn('workspace', r)
self.assertEqual(self.workspace_name, r['workspace'])
# TEST delete_store
response = self.geoserver_engine.delete_store(store_id=expected_store_id, purge=True, recurse=True)
# Failure Check
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_coverage_resource_world_file_tif(self):
# pk50095.zip
# call methods: create_coverage_resource, list_layers, get_layer, delete_layer
# TEST create_coverage resource
store_name = random_string_generator(10)
expected_store_id = '{}:{}'.format(self.workspace_name, store_name)
expected_coverage_type = 'worldimage'
coverage_file_name = 'Pk50095.zip'
coverage_name = coverage_file_name.split('.')[0]
coverage_file = os.path.join(self.files_root, "img_sample", coverage_file_name)
# Execute
response = self.geoserver_engine.create_coverage_resource(store_id=expected_store_id,
coverage_type=expected_coverage_type,
coverage_file=coverage_file,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Tests
self.assertIn(coverage_name, r['name'])
self.assertEqual(self.workspace_name, r['workspace'])
# TEST list_layers
# Execute
response = self.geoserver_engine.list_layers()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# Check if layer is in list
self.assertIn(coverage_name, result)
# TEST get_layer
# Execute
layer_id = '{}:{}'.format(self.workspace_name, coverage_name)
response = self.geoserver_engine.get_layer(layer_id=layer_id,
store_id=store_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn(store_name, r['store'])
self.assertIn(self.workspace_name, self.workspace_name)
# TEST delete_layer
self.geoserver_engine.delete_layer(layer_id=coverage_name,
store_id=store_name)
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_coverage_resource_upload(self):
# DO NOT MOCK
# Use in memory file list: precip30min.prj & precip30min.asc
# call methods: create_coverage_resource, list_resources, get_resource, delete_resource
store_id_name = random_string_generator(10)
expected_store_id = '{}:{}'.format(self.workspace_name, store_id_name)
expected_coverage_type = 'arcgrid'
coverage_file_name = 'precip30min.asc'
prj_file_name = 'precip30min.prj'
coverage_name = coverage_file_name.split('.')[0]
arc_sample = os.path.join(self.files_root, "arc_sample")
coverage_file = os.path.join(arc_sample, coverage_file_name)
prj_file = os.path.join(arc_sample, prj_file_name)
with open(coverage_file, 'rb') as coverage_upload:
with open(prj_file, 'rb') as prj_upload:
upload_list = [coverage_upload, prj_upload]
# Execute
response = self.geoserver_engine.create_coverage_resource(store_id=expected_store_id,
coverage_type=expected_coverage_type,
coverage_upload=upload_list,
overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Values
self.assertEqual(coverage_name, r['name'])
self.assertEqual(self.workspace_name, r['workspace'])
# TEST list_resources
# Execute
response = self.geoserver_engine.list_resources()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# layer listed
self.assertIn(coverage_name, result)
# TEST get_resources
# Execute
resource_id = "{}:{}".format(self.workspace_name, coverage_name)
response = self.geoserver_engine.get_resource(resource_id=resource_id,
store_id=store_id_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertEquals(coverage_name, r['name'])
self.assertIn(coverage_name, r['wcs']['arcgrid'])
# TEST delete_resource
# TODO: delete_resource is returning a 403 error: not authorized.
# Execute
# This case the resource id is the same as the filename.
resource_id = '{}:{}'.format(self.workspace_name, coverage_name)
response = self.geoserver_engine.delete_resource(resource_id=resource_id,
store_id=store_id_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
# self.assertTrue(response['success'])
def test_create_layer_group(self):
# call methods: create_layer_group, list_layer_groups, get_layer_group, delete_layer_group
# create_layer_group
# Use existing layers and styles in geoserver:
# layers: sf:roads, sf:bugsites, sf:streams;
# styles: simple_roads, capitals, simple_streams
# TEST create_layer_group
# Do create
# expected_layer_group_id = '{}:{}'.format(self.workspace_name, random_string_generator(10))
expected_layer_group_id = random_string_generator(10)
expected_layers = ['roads', 'bugsites', 'streams']
expected_styles = ['simple_roads', 'capitals', 'simple_streams']
# TODO: create_layer_group: fails on catalog.save() when workspace is given.
response = self.geoserver_engine.create_layer_group(layer_group_id=expected_layer_group_id,
layers=expected_layers,
styles=expected_styles)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
# Validate
result = response['result']
self.assertEquals(result['name'], expected_layer_group_id)
self.assertEquals(result['layers'], expected_layers)
self.assertEquals(result['styles'], expected_styles)
# TEST list_layer_groups
# Execute
response = self.geoserver_engine.list_layer_groups()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# layer group listed
self.assertIn(expected_layer_group_id, result)
# TEST get layer_group
# Execute
response = self.geoserver_engine.get_layer_group(layer_group_id=expected_layer_group_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# List of dictionaries
self.assertIn('workspace', r)
self.assertEqual(None, r['workspace'])
self.assertIn('layers', r)
self.assertEqual(expected_layers, r['layers'])
self.assertIn('styles', r)
self.assertEqual(expected_styles, r['styles'])
self.assertNotIn('dom', r)
# TEST delete layer group
# Clean up
self.geoserver_engine.delete_layer_group(layer_group_id=expected_layer_group_id)
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
# self.assertIsNone(response['result'])
def test_create_workspace(self):
# call methods: create_workspace, list_workspaces, get_workspace, delete_workspace
# TEST create workspace
expected_workspace_id = random_string_generator(10)
expected_uri = 'http://www.tethysplatform.org/{}'.format(expected_workspace_id)
# create workspace test
response = self.geoserver_engine.create_workspace(workspace_id=expected_workspace_id, uri=expected_uri)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn('name', r)
self.assertEqual(expected_workspace_id, r['name'])
# TEST list workspace
# Execute
response = self.geoserver_engine.list_workspaces()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# TEST layer group listed
self.assertIn(expected_workspace_id, result)
# TEST get_workspace
# Execute
response = self.geoserver_engine.get_workspace(workspace_id=expected_workspace_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(r['name'], expected_workspace_id)
# TEST delete work_space
# Do delete
response = self.geoserver_engine.delete_workspace(workspace_id=expected_workspace_id)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_create_style(self):
# call methods: create_style, list_styles, get_style, delete_style
# TEST create_style
expected_style_id_name = random_string_generator(10)
expected_style_id = '{}:{}'.format(self.workspace_name, expected_style_id_name)
style_file_name = 'point.sld'
expected_sld = os.path.join(self.files_root, style_file_name)
# Execute
with open(expected_sld, 'r') as sld_file:
sld_string = sld_file.read()
# TODO: create_style: Fails on when overwrite is False.
response = self.geoserver_engine.create_style(style_id=expected_style_id, sld=sld_string, overwrite=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# TEST list_styles
# Execute
response = self.geoserver_engine.list_styles(workspace=self.workspace_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# TEST layer listed
self.assertIn(expected_style_id_name, result)
# TEST get_style
# Execute
response = self.geoserver_engine.get_style(style_id=expected_style_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(r['name'], expected_style_id)
self.assertIn('workspace', r)
self.assertEqual(self.workspace_name, r['workspace'])
# TEST delete_style
# Do delete
response = self.geoserver_engine.delete_style(style_id=expected_style_id)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_link_and_add_table(self):
# call methods: link_sqlalchemy_db_to_geoserver, add_table_to_postgis_store, list_stores, get_store,
# delete_store
self.setup_postgis_table()
# TEST link_sqlalchemy_db_to_geoserver
store_id_name = random_string_generator(10)
store_id = '{}:{}'.format(self.workspace_name, store_id_name)
sqlalchemy_engine = create_engine(self.pg_url)
response = self.geoserver_engine.link_sqlalchemy_db_to_geoserver(store_id=store_id,
sqlalchemy_engine=sqlalchemy_engine,
docker=True)
# Check for success response
self.assertTrue(response['success'])
sqlalchemy_engine.dispose()
# TEST add_table_to_postgis_store
# Execute
response = self.geoserver_engine.add_table_to_postgis_store(store_id=store_id,
table=self.pg_table_name)
# Check for success response
self.assertTrue(response['success'])
# TEST list_stores
# Execute
response = self.geoserver_engine.list_stores()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# layer group listed
self.assertIn(store_id_name, result)
# TEST get store
# Execute
response = self.geoserver_engine.get_store(store_id=store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(store_id_name, r['name'])
self.assertIn('workspace', r)
self.assertEqual(self.workspace_name, r['workspace'])
# TEST delete_store
response = self.geoserver_engine.delete_store(store_id=store_id, purge=True, recurse=True)
# Failure Check
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_postgis_feature_resource(self):
# call methods: create_postgis_feature_resource (with table), list_stores, get_store, delete_store
self.setup_postgis_table()
# TEST create_postgis_feature_resource (with table)
store_id_name = random_string_generator(10)
store_id = '{}:{}'.format(self.workspace_name, store_id_name)
response = self.geoserver_engine.create_postgis_feature_resource(store_id=store_id,
host=self.pg_host,
port=self.pg_port,
database=self.pg_database,
user=self.pg_username,
password=self.pg_password,
table=self.pg_table_name)
self.assertTrue(response['success'])
# TEST list_stores
# Execute
response = self.geoserver_engine.list_stores()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# layer group listed
self.assertIn(store_id_name, result)
# TEST get store
# Execute
response = self.geoserver_engine.get_store(store_id=store_id)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertIn(store_id_name, r['name'])
self.assertIn('workspace', r)
self.assertEqual(self.workspace_name, r['workspace'])
# TEST delete_store
response = self.geoserver_engine.delete_store(store_id=store_id, purge=True, recurse=True)
# Failure Check
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
def test_create_sql_view(self):
# call methods: create_sql_view, list_resources, list_stores, list_layers
self.setup_postgis_table()
# TEST create_postgis_feature_resource (with table)
store_id_name = random_string_generator(10)
store_id = '{}:{}'.format(self.workspace_name, store_id_name)
response = self.geoserver_engine.create_postgis_feature_resource(store_id=store_id,
host=self.pg_host,
port=self.pg_port,
database=self.pg_database,
user=self.pg_username,
password=self.pg_password,
table=self.pg_table_name)
self.assertTrue(response['success'])
feature_type_name = random_string_generator(10)
postgis_store_id = '{}:{}'.format(self.workspace_name, store_id_name)
sql = "SELECT * FROM {}".format(self.pg_table_name)
geometry_column = self.geometry_column
geometry_type = self.geometry_type
response = self.geoserver_engine.create_sql_view(feature_type_name=feature_type_name,
postgis_store_id=postgis_store_id,
sql=sql,
geometry_column=geometry_column,
geometry_type=geometry_type)
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
self.assertIn('name', r)
self.assertIn(feature_type_name, r['name'])
# TEST list_resources
# Execute
response = self.geoserver_engine.list_resources()
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# layer listed
self.assertIn(feature_type_name, result)
# TEST get_resources
# Execute
# Geoserver uses the store_id as the layer/resource name (not the filename)
resource_id_name = '{}:{}'.format(self.workspace_name, feature_type_name)
response = self.geoserver_engine.get_resource(resource_id=resource_id_name)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
r = response['result']
# Type
self.assertIsInstance(r, dict)
# Properties
self.assertIn('name', r)
self.assertEquals(feature_type_name, r['name'])
self.assertIn(feature_type_name, r['wfs']['shapefile'])
# TEST delete_resource
# Execute
# This case the resource id is the same as the store id.
response = self.geoserver_engine.delete_resource(resource_id=resource_id_name,
store_id=store_id_name)
# Validate response object
self.assert_valid_response_object(response)
def map(request):
"""
Controller for the app map page.
"""
if request.method == "GET":
# get/check information from AJAX request
post_info = request.GET
watershed_ids = post_info.getlist("watershed_select")
group_id = post_info.get("watershed_group_select")
if not watershed_ids and not group_id:
return redirect("/apps/adhydro_streamflow/")
# get the base layer information
session = SettingsSessionMaker()
if watershed_ids:
# Query DB for settings
watersheds = (
session.query(Watershed)
.order_by(Watershed.watershed_name, Watershed.subbasin_name)
.filter(Watershed.id.in_(watershed_ids))
.all()
)
elif group_id:
# Query DB for settings
watersheds = (
session.query(Watershed)
.order_by(Watershed.watershed_name, Watershed.subbasin_name)
.filter(Watershed.watershed_groups.any(WatershedGroup.id == group_id))
.all()
)
##find all kml files to add to page
kml_file_location = os.path.join(os.path.dirname(os.path.realpath(__file__)), "public", "kml")
layers_info = []
# add kml urls to list and add their navigation items as well
group_id = 0
for watershed in watersheds:
# if on the local server
if watershed.geoserver_id == 1:
file_path = os.path.join(kml_file_location, format_name(watershed.watershed_name))
kml_info = {"watershed": watershed.folder_name, "subbasin": watershed.file_name}
# prepare kml files
drainage_line_kml = os.path.join(file_path, watershed.kml_drainage_line_layer)
if os.path.exists(drainage_line_kml) and watershed.kml_drainage_line_layer:
drainage_line_kml = os.path.basename(drainage_line_kml)
kml_info["drainage_line"] = "/static/adhydro_streamflow/kml/%s/%s" % (
watershed.folder_name,
watershed.kml_drainage_line_layer,
)
catchment_kml = os.path.join(file_path, watershed.kml_catchment_layer)
if os.path.exists(catchment_kml) and watershed.kml_catchment_layer:
catchment_kml = os.path.basename(catchment_kml)
kml_info["catchment"] = "/static/adhydro_streamflow/kml/%s/%s" % (
watershed.folder_name,
watershed.kml_catchment_layer,
)
gage_kml = os.path.join(file_path, watershed.kml_gage_layer)
if os.path.exists(gage_kml) and watershed.kml_gage_layer:
catchment_kml = os.path.basename(gage_kml)
kml_info["gage"] = "/static/adhydro_streamflow/kml/%s/%s" % (
watershed.folder_name,
watershed.kml_gage_layer,
)
kml_info["title"] = format_watershed_title(watershed.watershed_name, watershed.subbasin_name)
layers_info.append(kml_info)
# if geoserver
else: # (get geoserver info)
geoserver_info = {
"watershed": watershed.folder_name,
"subbasin": watershed.file_name,
"geoserver_url": "%s/wms" % watershed.geoserver.url,
}
engine = GeoServerSpatialDatasetEngine(
endpoint="%s/rest" % watershed.geoserver.url,
username=watershed.geoserver.username,
password=watershed.geoserver.password,
)
# load drainage line layer if exists
drainage_line_info = engine.get_resource(resource_id=watershed.geoserver_drainage_line_layer.strip())
if drainage_line_info["success"]:
# check layers attributes to see if valid
layer_attributes = drainage_line_info["result"]["attributes"]
missing_attributes = []
contained_attributes = []
# check required attributes
# necessary_attributes = ['COMID','watershed', 'subbasin', 'wwatershed','wsubbasin']
def find_add_attribute_ci(attribute, layer_attributes, contained_attributes):
"""
Case insensitive attribute search and add
"""
for layer_attribute in layer_attributes:
if layer_attribute.lower() == attribute.lower():
contained_attributes.append(layer_attribute)
return True
return False
# check COMID/HydroID attribute
if not find_add_attribute_ci("COMID", layer_attributes, contained_attributes):
missing_attributes.append("COMID")
if not find_add_attribute_ci("HydroID", layer_attributes, contained_attributes):
missing_attributes.append("HydroID")
# check ADHydro watershed/subbasin attributes
if not find_add_attribute_ci(
"watershed", layer_attributes, contained_attributes
) or not find_add_attribute_ci("subbasin", layer_attributes, contained_attributes):
missing_attributes.append("watershed")
missing_attributes.append("subbasin")
# check optional attributes
optional_attributes = ["usgs_id", "nws_id", "hydroserve"]
for optional_attribute in optional_attributes:
find_add_attribute_ci(optional_attribute, layer_attributes, contained_attributes)
latlon_bbox = drainage_line_info["result"]["latlon_bbox"][:4]
geoserver_info["drainage_line"] = {
"name": watershed.geoserver_drainage_line_layer,
"geojsonp": drainage_line_info["result"]["wfs"]["geojsonp"],
"latlon_bbox": [latlon_bbox[0], latlon_bbox[2], latlon_bbox[1], latlon_bbox[3]],
"projection": drainage_line_info["result"]["projection"],
"contained_attributes": contained_attributes,
"missing_attributes": missing_attributes,
}
# check if needed attribute is there to perfrom query based rendering of layer
if "Natur_Flow" not in layer_attributes:
geoserver_info["drainage_line"]["geoserver_method"] = "simple"
else:
geoserver_info["drainage_line"]["geoserver_method"] = "natur_flow_query"
# load catchment layer if exists
catchment_info = engine.get_resource(resource_id=watershed.geoserver_catchment_layer.strip())
if catchment_info["success"]:
latlon_bbox = catchment_info["result"]["latlon_bbox"][:4]
geoserver_info["catchment"] = {
"name": watershed.geoserver_catchment_layer,
"latlon_bbox": [latlon_bbox[0], latlon_bbox[2], latlon_bbox[1], latlon_bbox[3]],
"projection": catchment_info["result"]["projection"],
}
# load gage layer if exists
gage_info = engine.get_resource(resource_id=watershed.geoserver_gage_layer.strip())
if gage_info["success"]:
latlon_bbox = gage_info["result"]["latlon_bbox"][:4]
geoserver_info["gage"] = {
"name": watershed.geoserver_gage_layer,
"latlon_bbox": [latlon_bbox[0], latlon_bbox[2], latlon_bbox[1], latlon_bbox[3]],
"projection": gage_info["result"]["projection"],
}
geoserver_info["title"] = format_watershed_title(watershed.watershed_name, watershed.subbasin_name)
layers_info.append(geoserver_info)
group_id += 1
watershed_list = []
for watershed in watersheds:
watershed_list.append(
(
"%s (%s)" % (watershed.watershed_name, watershed.subbasin_name),
"%s:%s" % (watershed.folder_name, watershed.file_name),
)
)
watershed_select = {
"display_text": "Select Watershed",
"name": "watershed_select",
"options": watershed_list,
"placeholder": "Select Watershed",
}
units_toggle_switch = {
"display_text": "Units",
"name": "units-toggle",
"on_label": "Metric",
"off_label": "English",
"initial": True,
}
# Query DB for settings
main_settings = session.query(MainSettings).order_by(MainSettings.id).first()
base_layer = main_settings.base_layer
session.close()
base_layer_info = {"name": base_layer.name, "api_key": base_layer.api_key}
context = {
"layers_info_json": json.dumps(layers_info),
"layers_info": layers_info,
"base_layer_info": json.dumps(base_layer_info),
"watershed_select": watershed_select,
"units_toggle_switch": units_toggle_switch,
}
return render(request, "adhydro_streamflow/map.html", context)
# send them home
return redirect("/apps/adhydro_streamflow/")
class TestGeoServerDatasetEngine(unittest.TestCase):
def setUp(self):
# Globals
self.debug = False
# Files
self.tests_root = os.path.abspath(os.path.dirname(__file__))
self.files_root = os.path.join(self.tests_root, 'files')
self.shapefile_name = 'test'
self.shapefile_base = os.path.join(self.files_root, 'shapefile', self.shapefile_name)
# Create Test Engine
self.engine = GeoServerSpatialDatasetEngine(endpoint=TEST_GEOSERVER_DATASET_SERVICE['ENDPOINT'],
username=TEST_GEOSERVER_DATASET_SERVICE['USERNAME'],
password=TEST_GEOSERVER_DATASET_SERVICE['PASSWORD'])
# Create Test Workspaces
# self.test_resource_workspace = random_string_generator(10)
self.test_resource_workspace = random_string_generator(10)
self.engine.create_workspace(workspace_id=self.test_resource_workspace, uri=random_string_generator(5))
# Create Test Stores/Resources/Layers
## Shapefile
# Store name
self.test_resource_store = random_string_generator(10)
# Resource and Layer will take the name of the file
self.test_resource_name = self.test_resource_store
self.test_layer_name = self.test_resource_store
# Identifiers of the form 'workspace:item'
self.test_store_identifier = '{0}:{1}'.format(self.test_resource_workspace, self.test_resource_store)
self.test_resource_identifier = '{0}:{1}'.format(self.test_resource_workspace, self.test_resource_name)
# Do create shapefile
self.engine.create_shapefile_resource(self.test_store_identifier, shapefile_base=self.shapefile_base,
overwrite=True)
## Coverage
# Create Test Style
self.test_style_name = 'point'
# Create Test Layer Groups
self.test_layer_group_name = random_string_generator(10)
self.engine.create_layer_group(layer_group_id=self.test_layer_group_name,
layers=(self.test_layer_name,),
styles=(self.test_style_name,))
# Pause
pause(10)
def tearDown(self):
# Delete test layer groups
self.engine.delete_layer_group(layer_group_id=self.test_layer_group_name)
# Delete test resources & layers
self.engine.delete_resource(self.test_resource_identifier, recurse=True)
# Delete stores
self.engine.delete_store(self.test_store_identifier)
# Delete test workspace
self.engine.delete_workspace(self.test_resource_workspace)
def assert_valid_response_object(self, response_object):
# Response object should be a dictionary with the keys 'success' and either 'result' if success is True
# or 'error' if success is False
self.assertIsInstance(response_object, dict)
self.assertIn('success', response_object)
if isinstance(response_object, dict) and 'success' in response_object:
if response_object['success'] is True:
self.assertIn('result', response_object)
elif response_object['success'] is False:
self.assertIn('error', response_object)
def test_list_resources(self):
pause(10)
# Execute
response = self.engine.list_resources(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer listed
self.assertIn(self.test_resource_name, result)
def test_list_resources_with_properties(self):
# Execute
response = self.engine.list_resources(with_properties=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_resource_in = False
for r in result:
if r['name'] == self.test_resource_name:
test_resource_in = True
break
self.assertTrue(test_resource_in)
def test_list_layers(self):
# Execute
response = self.engine.list_layers(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer listed
self.assertIn(self.test_layer_name, result)
def test_list_layers_with_properties(self):
# Execute
response = self.engine.list_layers(with_properties=True)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_layer_in = False
for r in result:
if r['name'] == self.test_layer_name:
test_layer_in = True
break
self.assertTrue(test_layer_in)
def test_list_layer_groups(self):
# Execute
response = self.engine.list_layer_groups(debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# List of strings
if len(result) > 0:
self.assertIsInstance(result[0], str)
# Test layer group listed
self.assertIn(self.test_layer_group_name, result)
def test_list_layer_groups_with_properties(self):
# Execute
response = self.engine.list_layer_groups(with_properties=True, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Returns list
self.assertIsInstance(result, list)
# List of dictionaries
if len(result) > 0:
self.assertIsInstance(result[0], dict)
# Test layer included
test_layer_group_in = False
for r in result:
if r['name'] == self.test_layer_group_name:
test_layer_group_in = True
break
self.assertTrue(test_layer_group_in)
def test_list_workspaces(self):
pass
def test_list_stores(self):
pass
def test_list_styles(self):
pass
def test_get_resource(self):
# Execute
response = self.engine.get_resource(resource_id=self.test_resource_name, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('workspace', result)
self.assertEqual(result['workspace'], self.test_resource_workspace)
def test_get_resource_with_workspace(self):
# Execute
response = self.engine.get_resource(resource_id=self.test_resource_identifier,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertIn('workspace', result)
self.assertEqual(result['name'], self.test_resource_name)
self.assertEqual(result['workspace'], self.test_resource_workspace)
def test_get_resource_with_store(self):
# Execute
response = self.engine.get_resource(resource_id=self.test_resource_name,
store=self.test_resource_store,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertIn('store', result)
self.assertEqual(result['name'], self.test_resource_name)
self.assertEqual(result['store'], self.test_resource_store)
def test_get_resource_multiple_with_name(self):
pass
def test_get_layer(self):
# Execute
response = self.engine.get_layer(layer_id=self.test_layer_name, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertEqual(result['name'], self.test_layer_name)
def test_get_layer_group(self):
# Execute
response = self.engine.get_layer_group(layer_group_id=self.test_layer_group_name, debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Type
self.assertIsInstance(result, dict)
# Properties
self.assertIn('name', result)
self.assertEqual(result['name'], self.test_layer_group_name)
def test_get_store(self):
pass
def test_get_workspace(self):
pass
def test_get_style(self):
pass
def test_update_resource(self):
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(resource_id=self.test_resource_name,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(resource_id=self.test_resource_name, debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_resource_workspace(self):
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(resource_id=self.test_resource_identifier,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(resource_id=self.test_resource_identifier,
debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_resource_store(self):
pause(10)
# Setup
new_title = random_string_generator(15)
# Execute
response = self.engine.update_resource(resource_id=self.test_resource_name,
store=self.test_resource_store,
title=new_title,
debug=self.debug)
# Validate response object
self.assert_valid_response_object(response)
# Success
self.assertTrue(response['success'])
# Extract Result
result = response['result']
# Get new resource
updated_response = self.engine.get_resource(resource_id=self.test_resource_name,
store=self.test_resource_store,
debug=self.debug)
updated_result = updated_response['result']
# Properties
self.assertEqual(result['title'], new_title)
self.assertEqual(updated_result['title'], new_title)
self.assertEqual(result['title'], updated_result['title'])
self.assertEqual(result, updated_result)
def test_update_layer(self):
# Get original
old_response = self.engine.get_layer(layer_id=self.test_layer_name)
# Update
new_default_style = self.test_style_name
response = self.engine.update_layer(layer_id=self.test_layer_name,
default_style=new_default_style,
debug=self.debug)
# Update should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
old_result = old_response['result']
result = response['result']
self.assertEqual(result['default_style'], new_default_style)
self.assertNotEqual(old_result['default_style'], result['default_style'])
def test_update_layer_group(self):
pass
def test_delete_resource(self):
# Must delete layer group and layer first
self.engine.delete_layer_group(layer_group_id=self.test_layer_group_name)
self.engine.delete_layer(layer_id=self.test_layer_name)
# Do delete
response = self.engine.delete_resource(resource_id=self.test_resource_identifier)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_resource_belongs_to_layer(self):
# Do delete without deleting layer group and layer
response = self.engine.delete_resource(resource_id=self.test_resource_identifier)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_resource_recurse(self):
# Force delete with recurse
response = self.engine.delete_resource(resource_id=self.test_resource_identifier, recurse=True)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_resource_does_not_exist(self):
# Do delete
response = self.engine.delete_resource(resource_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer(self):
# Delete layer group first
self.engine.delete_layer_group(layer_group_id=self.test_layer_group_name)
# Do delete
response = self.engine.delete_layer(layer_id=self.test_layer_name)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_belongs_to_group(self):
# Do delete without deleting layer group
response = self.engine.delete_layer(layer_id=self.test_layer_name)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer_recurse(self):
# Force delete with recurse
response = self.engine.delete_layer(layer_id=self.test_layer_name, recurse=True)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_does_not_exist(self):
# Delete layer group first
self.engine.delete_layer_group(layer_group_id=self.test_layer_group_name)
# Do delete
response = self.engine.delete_layer(layer_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_layer_group(self):
# Do delete
response = self.engine.delete_layer_group(layer_group_id=self.test_layer_group_name)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
self.assertIsNone(response['result'])
def test_delete_layer_group_does_not_exist(self):
# Do delete
response = self.engine.delete_layer_group(layer_group_id='iDontExist')
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_delete_workspace(self):
pass
def test_delete_store(self):
pass
def test_delete_style(self):
pass
def test_create_layer_group(self):
# Do create
name = random_string_generator(10)
layers = (self.test_layer_name,)
styles = (self.test_style_name,)
response = self.engine.create_layer_group(layer_group_id=name, layers=layers, styles=styles)
# Should succeed
self.assert_valid_response_object(response)
self.assertTrue(response['success'])
# Validate
result = response['result']
self.assertEqual(result['name'], name)
self.assertEqual(result['layers'], layers)
self.assertEqual(result['styles'], [])
# Clean up
self.engine.delete_layer_group(layer_group_id=name)
def test_create_layer_group_mismatch_layers_styles(self):
# Do create with differing number of styles and layers
name = random_string_generator(10)
layers = (self.test_layer_name,)
styles = (self.test_style_name, self.test_style_name)
response = self.engine.create_layer_group(layer_group_id=name, layers=layers, styles=styles)
# Should fail
self.assert_valid_response_object(response)
self.assertFalse(response['success'])
def test_create_shapefile_resource(self):
self.assertTrue(False)
def test_create_coverage_resource(self):
self.assertTrue(False)
def test_create_workspace(self):
self.assertTrue(False)
def test_create_style(self):
self.assertTrue(False)
def test_create_sql_view(self):
self.assertTrue(False)
