def test_geometry(self):
platform_deployment = PlatformDeployment()
platform_deployment.reference_designator = 'TEST0000'
platform_deployment.geo_location = 'POINT(-70 40)'
db.session.add(platform_deployment)
db.session.commit()
pd = PlatformDeployment.query.filter(PlatformDeployment.reference_designator=='TEST0000').first()
self.assertEquals(pd.geojson, {'coordinates': [-70, 40], 'type': 'Point'})
def test_geometry(self):
platform_deployment = PlatformDeployment()
platform_deployment.reference_designator = "TEST0000"
platform_deployment.geo_location = "POINT(-70 40)"
db.session.add(platform_deployment)
db.session.commit()
pd = PlatformDeployment.query.filter(PlatformDeployment.reference_designator == "TEST0000").first()
self.assertEquals(pd.geojson, {"coordinates": [-70, 40], "type": "Point"})
def test_geometry(self):
platform_deployment = PlatformDeployment()
platform_deployment.reference_designator = 'TEST0000'
platform_deployment.geo_location = 'POINT(-70 40)'
db.session.add(platform_deployment)
db.session.commit()
pd = PlatformDeployment.query.filter(
PlatformDeployment.reference_designator == 'TEST0000').first()
self.assertEquals(pd.geojson, {
'coordinates': [-70, 40],
'type': 'Point'
})
def test_platform_deployment(self):
# Test the json in the object
platform_deployment = PlatformDeployment()
self.assertTrue(
platform_deployment.to_json()
== {
"id": None,
"array_id": None,
"display_name": None,
"end_date": None,
"geo_location": None,
"reference_designator": None,
"start_date": None,
}
)
def get_uframe_toc():
uframe_url = current_app.config['UFRAME_URL'] + current_app.config['UFRAME_TOC']
r = requests.get(uframe_url)
if r.status_code == 200:
d = r.json()
for row in d:
try:
# FIX FOR THE WRONG WAY ROUND
temp1 = row['platform_code']
temp2 = row['mooring_code']
row['mooring_code'] = temp1
row['platform_code'] = temp2
#
instrument_display_name = PlatformDeployment._get_display_name(row['reference_designator'])
split_name = instrument_display_name.split(' - ')
row['instrument_display_name'] = split_name[-1]
row['mooring_display_name'] = split_name[0]
row['platform_display_name'] = split_name[1]
except:
row['instrument_display_name'] = ""
row['platform_display_name'] = ""
row['mooring_display_name'] = ""
return d
else:
return []
def get_uframe_toc():
uframe_url = current_app.config['UFRAME_URL'] + current_app.config[
'UFRAME_TOC']
r = requests.get(uframe_url)
if r.status_code == 200:
d = r.json()
for row in d:
try:
# FIX FOR THE WRONG WAY ROUND
temp1 = row['platform_code']
temp2 = row['mooring_code']
row['mooring_code'] = temp1
row['platform_code'] = temp2
#
instrument_display_name = PlatformDeployment._get_display_name(
row['reference_designator'])
split_name = instrument_display_name.split(' - ')
row['instrument_display_name'] = split_name[-1]
row['mooring_display_name'] = split_name[0]
row['platform_display_name'] = split_name[1]
except:
row['instrument_display_name'] = ""
row['platform_display_name'] = ""
row['mooring_display_name'] = ""
return d
else:
return []
def test_route_get_platform_deployments(self):
#Create a sample data set.
platform_ref = PlatformDeployment(reference_designator='CE01ISSM')
db.session.add(platform_ref)
db.session.commit()
platform_ref2 = PlatformDeployment(
reference_designator='GS05MOAS-PG002')
db.session.add(platform_ref2)
db.session.commit()
content_type = 'application/json'
response = self.client.get(url_for('main.get_platform_deployments'),
content_type=content_type)
all_data = response.data
expected_data = json.loads(response.data)
self.assertTrue(response.status_code == 200)
response = self.client.get(url_for('main.get_platform_deployment',
id='CE01ISSM'),
content_type=content_type)
self.assertTrue(response.status_code == 200)
response = self.client.get('/platform_deployments?array_id=3')
self.assertTrue(response.status_code == 200)
response = self.client.get('/platform_deployments?array_id=999')
self.assertTrue(response.status_code == 200)
data = json.loads(response.data)
no_data = {'platform_deployments': []}
self.assertTrue(data == no_data)
response = self.client.get(
'/platform_deployments?ref_id="GS05MOAS-PG002"')
self.assertTrue(response.status_code == 200)
# search for not existent platform; all platforms returned
response = self.client.get('/platform_deployments?ref_id="badthing"')
self.assertTrue(response.status_code == 200)
data = json.loads(response.data)
self.assertTrue(data == expected_data)
response = self.client.get('/platform_deployments?search="CE01ISSM"')
self.assertTrue(response.status_code == 200)
def test_get_display_name(self):
content_type = 'application/json'
# Create a sample data set.
platform_ref = PlatformDeployment(reference_designator='CE01ISSM')
platform_ref.geo_location = 'POINT(-70 40)'
db.session.add(platform_ref)
db.session.commit()
platform_ref2 = PlatformDeployment(reference_designator='GS03FLMA-RIS02')
platform_ref2.geo_location = 'POINT(-70 40)'
db.session.add(platform_ref2)
db.session.commit()
response = self.client.get(url_for('main.get_display_name', reference_designator='GS03FLMA-RIS02'), content_type=content_type)
self.assertEquals(response.status_code, 200)
response = self.client.get(url_for('main.get_display_name'), content_type=content_type)
self.assertEquals(response.status_code, 204)
response = self.client.get(url_for('main.get_display_name', reference_designator='GS03FLMA-RIXXX'), content_type=content_type)
self.assertEquals(response.status_code, 204)
response = self.client.get(url_for('main.get_display_name', reference_designator='GS03FLMA-RIXXX-99-ABCDEF000'),
content_type=content_type)
self.assertEquals(response.status_code, 200)
response = self.client.get(url_for('main.get_display_name', reference_designator='GS03FLMA-RIXXX-BAD'), content_type=content_type)
self.assertEquals(response.status_code, 204)
# Create platform deployment for foreign key constraints when creating
# instrument_deployment (note: using platform_deployment with actual id=203)
GS05MOAS_PG002_rd = 'GS05MOAS-PG002'
GS05MOAS_PG002 = PlatformDeployment(reference_designator=GS05MOAS_PG002_rd)
db.session.add(GS05MOAS_PG002)
db.session.commit()
GS05MOAS_PG002_id = GS05MOAS_PG002.id
number_of_platform_deployments = 1
# Create instrument(s) for previously created platform deployment; required for
# foreign keys - otherwise foreign key violation received.
number_of_instruments = 1
FLORDM000_rd = 'GS05MOAS-PG002-02-FLORDM000'
FLORDM000 = InstrumentDeployment(reference_designator=FLORDM000_rd)
FLORDM000.depth = 1000.0
FLORDM000.display_name = '2-Wavelength Fluorometer'
FLORDM000.end_date = dt.datetime.now()
FLORDM000.geo_location = 'POINT(-70 40)'
FLORDM000.platform_deployment_id = GS05MOAS_PG002_id # actual 754
FLORDM000.reference_designator = FLORDM000_rd
FLORDM000.start_date = dt.datetime.now()
db.session.add(FLORDM000)
db.session.commit()
response = self.client.get(url_for('main.get_display_name', reference_designator='GS05MOAS-PG002-02-FLORDM000'),
content_type=content_type)
self.assertEquals(response.status_code, 200)
def test_route_get_instrument_deployment_with_unknown_platform_deployment_id(
self):
content_type = 'application/json'
# platform deployment GS05MOAS_PG002
GS05MOAS_PG002_rd = 'GS05MOAS-PG002'
GS05MOAS_PG002 = PlatformDeployment(
reference_designator=GS05MOAS_PG002_rd)
db.session.add(GS05MOAS_PG002)
db.session.commit()
GS05MOAS_PG002_id = GS05MOAS_PG002.id
# instrument deployment FLORDM000
FLORDM000_rd = 'GS05MOAS-PG002-02-FLORDM000'
FLORDM000 = InstrumentDeployment(reference_designator=FLORDM000_rd)
FLORDM000.depth = 1000.0
FLORDM000.display_name = '2-Wavelength Fluorometer'
FLORDM000.end_date = dt.datetime.now()
FLORDM000.geo_location = 'POINT(-70 40)'
FLORDM000.platform_deployment_id = GS05MOAS_PG002_id # actual 754
FLORDM000.reference_designator = FLORDM000_rd
FLORDM000.start_date = dt.datetime.now()
db.session.add(FLORDM000)
db.session.commit()
FLORDM000_id = FLORDM000.id
# Get all instrument deployments
response = self.client.get(url_for('main.get_instrument_deployments'),
content_type=content_type)
all_data = json.loads(response.data)
self.assertIn('instrument_deployments', all_data)
list_all_data = all_data['instrument_deployments']
len_list_all_data = len(list_all_data)
self.assertTrue(len_list_all_data > 0)
self.assertTrue(response.status_code == 200)
# for platform_deployment_id which doesn't exist; expect failure (receive 200)
#TODO returns empty list of instrument_deployments and status_code 200; correct?
response = self.client.get(
'/instrument_deployment?platform_deployment_id=9999')
# Verify result return has instrument_deployments and list is empty
response_data = json.loads(response.data[:])
self.assertIn('instrument_deployments', response_data)
list_instrument_deployments = response_data['instrument_deployments']
len_list_instrument_deployments = len(list_instrument_deployments)
self.assertEquals(0, len(list_instrument_deployments))
self.assertEquals(response.status_code, 200)
self.assertTrue(all_data != response_data)
def test_route_get_platform_deployment_geojson_single(self):
content_type = 'application/json'
# Issue requests when no data available
response = self.client.get(url_for('main.get_platform_deployment_geojson_single'), content_type=content_type)
self.assertEquals(response.status_code, 204)
# Create a sample data set.
platform_ref = PlatformDeployment(reference_designator='CE01ISSM')
platform_ref.geo_location = 'POINT(-70 40)'
db.session.add(platform_ref)
db.session.commit()
platform_ref2 = PlatformDeployment(reference_designator='GS05MOAS-PG002')
platform_ref2.geo_location = 'POINT(-70 40)'
db.session.add(platform_ref2)
db.session.commit()
# Get platform_deployment
response = self.client.get(url_for('main.get_platform_deployment', id='CE01ISSM'), content_type=content_type)
self.assertTrue(response.status_code == 200)
'''
curl -X GET 'http://localhost:4000/platform_deployments/GS05MOAS-PG002'
{
"array_id": 6,
"display_name": "Global Southern Ocean Mobile (Open Ocean) - Profiler",
"end_date": null,
"geo_location": {
"coordinates": [
-89.6652,
-54.0814
],
"type": "Point"
},
"id": 203,
"reference_designator": "GS05MOAS-PG002",
"start_date": null
}
'''
# Request all
response = self.client.get(url_for('main.get_platform_deployment_geojson_single'), content_type=content_type)
self.assertEquals(response.status_code, 200)
# Request single reference_designator
response = self.client.get(url_for('main.get_platform_deployment_geojson_single', reference_designator='CE01ISSM'), content_type=content_type)
self.assertEquals(response.status_code, 200)
# Request single reference_designator
response = self.client.get(url_for('main.get_platform_deployment_geojson_single', reference_designator='NO-GOOD'), content_type=content_type)
self.assertEquals(response.status_code, 204)
def test_platform_deployment(self):
#Create a sample data set.
#TODO : This will be replaced by an endpoint
platform_ref = PlatformDeployment(
reference_designator='CE01ISSM-LM001')
db.session.add(platform_ref)
db.session.commit()
response = self.client.get(url_for('main.get_platform_deployments'), \
content_type = 'application/json')
self.assertTrue(response.status_code == 200)
response = self.client.get(url_for('main.get_platform_deployment', \
id='CE01ISSM-LM001'), content_type = 'application/json')
self.assertTrue(response.status_code == 200)
def test_get_display_name(self):
content_type = 'application/json'
# Create a sample data set.
platform_ref = PlatformDeployment(reference_designator='CE01ISSM')
platform_ref.geo_location = 'POINT(-70 40)'
db.session.add(platform_ref)
db.session.commit()
platform_ref2 = PlatformDeployment(
reference_designator='GS03FLMA-RIS02')
platform_ref2.geo_location = 'POINT(-70 40)'
db.session.add(platform_ref2)
db.session.commit()
response = self.client.get(url_for(
'main.get_display_name', reference_designator='GS03FLMA-RIS02'),
content_type=content_type)
self.assertEquals(response.status_code, 200)
response = self.client.get(url_for('main.get_display_name'),
content_type=content_type)
self.assertEquals(response.status_code, 204)
def test_platform_deployment(self):
#Test the json in the object
platform_deployment = PlatformDeployment()
self.assertTrue(platform_deployment.to_json() == {'id': None, \
'array_id': None, 'display_name': None, 'end_date': None, \
'geo_location': None, 'reference_designator': None, 'start_date': None})
def test_platform_deployment(self):
#Test the json in the object
platform_deployment = PlatformDeployment()
self.assertTrue(platform_deployment.to_json() == {'id': None, \
'array_id': None, 'display_name': None, 'end_date': None, \
'geo_location': None, 'reference_designator': None, 'start_date': None})
def test_post_instrument_deployment(self):
'''
create new instrument deployment
'''
headers = self.get_api_headers('admin', 'test')
# Create platform deployment for foreign key constraints when creating
# instrument_deployment (note: using platform_deployment with actual id=203)
GS05MOAS_PG002_rd = 'GS05MOAS-PG002'
GS05MOAS_PG002 = PlatformDeployment(reference_designator=GS05MOAS_PG002_rd)
db.session.add(GS05MOAS_PG002)
db.session.commit()
GS05MOAS_PG002_id = GS05MOAS_PG002.id
number_of_platform_deployments = 1
# Create instrument(s) for previously created platform deployment; required for
# foreign keys - otherwise foreign key violation received.
number_of_instruments = 1
FLORDM000_rd = 'GS05MOAS-PG002-02-FLORDM000'
FLORDM000 = InstrumentDeployment(reference_designator=FLORDM000_rd)
FLORDM000.depth = 1000.0
FLORDM000.display_name = '2-Wavelength Fluorometer'
FLORDM000.end_date = dt.datetime.now()
FLORDM000.geo_location = 'POINT(-70 40)'
FLORDM000.platform_deployment_id = GS05MOAS_PG002_id # actual 754
FLORDM000.reference_designator = FLORDM000_rd
FLORDM000.start_date = dt.datetime.now()
db.session.add(FLORDM000)
db.session.commit()
FLORDM000_id = FLORDM000.id
# Create data to post, do successful POST
FLORDM000_data = {'display_name': '2-Wavelength Fluorometer',
'platform_deployment_id': GS05MOAS_PG002_id,
'end_date': '2015-02-16',
'start_date': '2015-02-15',
'reference_designator': 'GS05MOAS-PG002-02-FLORDM000',
'depth': 500.0,
'geo_location': None,
'id': (FLORDM000_id+1)}
data = json.dumps(FLORDM000_data)
response = self.client.post(url_for('main.post_instrument_deployment'), headers=headers, data=data)
self.assertEquals(response.status_code, 201)
# Post invalid platform_deployment_id, raise integrity error
FLORDM000_data = {'display_name': '2-Wavelength Fluorometer',
'platform_deployment_id': 9999,
'end_date': '2015-02-16',
'start_date': '2015-02-15',
'reference_designator': 'GS05MOAS-PG002-02-FLORDM000',
'depth': 500.0,
'geo_location': None,
'id': (FLORDM000_id+1)}
data = json.dumps(FLORDM000_data)
response = self.client.post(url_for('main.post_instrument_deployment'), headers=headers, data=data)
self.assertEquals(response.status_code, 400)
self.assertTrue('violates foreign key constraint' in response.data)
# Post data=None, raise ValueError
response = self.client.post(url_for('main.post_instrument_deployment'), headers=headers, data=None)
self.assertEquals(response.status_code, 400)
self.assertTrue('No JSON object could be decoded' in response.data)
def test_put_instrument_deployment(self):
'''
update instrument deployment
'''
headers = self.get_api_headers('admin', 'test')
content_type = 'application/json'
# Create platform deployment for foreign key constraints when creating
# instrument_deployment (note: using platform_deployment with actual id=203)
GS05MOAS_PG002_rd = 'GS05MOAS-PG002'
GS05MOAS_PG002 = PlatformDeployment(
reference_designator=GS05MOAS_PG002_rd)
db.session.add(GS05MOAS_PG002)
db.session.commit()
GS05MOAS_PG002_id = GS05MOAS_PG002.id
number_of_platform_deployments = 1
# Create instrument(s) for previously created platform deployment; required for
# foreign keys - otherwise foreign key violation received.
number_of_instruments = 1
FLORDM000_rd = 'GS05MOAS-PG002-02-FLORDM000'
FLORDM000 = InstrumentDeployment(reference_designator=FLORDM000_rd)
FLORDM000.depth = 1000.0
FLORDM000.display_name = '2-Wavelength Fluorometer'
FLORDM000.end_date = dt.datetime.now()
FLORDM000.geo_location = 'POINT(-70 40)'
FLORDM000.platform_deployment_id = GS05MOAS_PG002_id # actual 754
FLORDM000.reference_designator = FLORDM000_rd
FLORDM000.start_date = dt.datetime.now()
db.session.add(FLORDM000)
db.session.commit()
FLORDM000_id = FLORDM000.id
# Create data to post
original_FLORDM000_data = {
'display_name': '2-Wavelength Fluorometer',
'platform_deployment_id': GS05MOAS_PG002_id,
'end_date': '2015-02-15',
'start_date': '2015-02-15',
'reference_designator': 'GS05MOAS-PG002-02-FLORDM000',
'depth': 1000.0,
'geo_location': {
'coordinates': [-70, 45],
'type': 'Point'
},
'id': FLORDM000_id
}
modified_FLORDM000_data = {
'display_name': '2-Wavelength Fluorometer',
'platform_deployment_id': GS05MOAS_PG002_id,
'end_date': '2015-02-16',
'start_date': '2015-02-15',
'reference_designator': 'GS05MOAS-PG002-02-FLORDM000',
'depth': 500.0,
'geo_location': None,
'id': FLORDM000_id
}
data = json.dumps(modified_FLORDM000_data)
response = self.client.put(url_for('main.put_instrument_deployment',
id=FLORDM000_id),
headers=headers,
data=data)
self.assertEquals(response.status_code, 200)
# Get updated instrument FLORDM000; compare to data modifications requested
response = self.client.get(url_for('main.get_instrument_deployment',
id=FLORDM000_id),
content_type=content_type)
self.assertTrue(response.status_code == 200)
FLORDM000_data = json.loads(response.data[:])
self.assertEquals(FLORDM000_data, modified_FLORDM000_data)
# Send unknown id for PUT, expect failure
data = json.dumps(modified_FLORDM000_data)
response = self.client.put(url_for('main.put_instrument_deployment',
id=999),
headers=headers,
data=data)
self.assertEquals(response.status_code, 404)
def test_delete_instrument_deployment(self):
headers = self.get_api_headers('admin', 'test')
content_type = 'application/json'
# Create platform deployment for foreign key constraints when creating
# instrument_deployment (note: using actual platform_deployment id 203)
GS05MOAS_PG002_rd = 'GS05MOAS-PG002'
GS05MOAS_PG002 = PlatformDeployment(
reference_designator=GS05MOAS_PG002_rd)
db.session.add(GS05MOAS_PG002)
db.session.commit()
GS05MOAS_PG002_id = GS05MOAS_PG002.id
number_of_platform_deployments = 1
# Create instrument(s) for preiously created platform deployment; required for
# foreign keys - otherwise foreign key violation received.
number_of_instruments = 2
#TODO General: Review, test and catch foreign key violations
FLORDM000_rd = 'GS05MOAS-PG002-02-FLORDM000'
FLORDM000 = InstrumentDeployment(reference_designator=FLORDM000_rd)
FLORDM000.depth = 1000.0
FLORDM000.display_name = '2-Wavelength Fluorometer'
FLORDM000.end_date = dt.datetime.now()
FLORDM000.geo_location = 'POINT(-70 40)'
FLORDM000.platform_deployment_id = GS05MOAS_PG002_id # actual 754
FLORDM000.reference_designator = FLORDM000_rd
FLORDM000.start_date = dt.datetime.now()
db.session.add(FLORDM000)
db.session.commit()
FLORDM000_id = FLORDM000.id
PARADM000_rd = 'GS05MOAS-PG002-04-PARADM000'
PARADM000 = InstrumentDeployment(reference_designator=PARADM000_rd)
PARADM000.depth = 1000.0
PARADM000.display_name = 'Photosynthetically Available Radiation'
PARADM000.end_date = dt.datetime.now()
PARADM000.geo_location = 'POINT(-70 40)'
PARADM000.platform_deployment_id = GS05MOAS_PG002_id # actual 774
PARADM000.reference_designator = PARADM000_rd
PARADM000.start_date = dt.datetime.now()
db.session.add(PARADM000)
db.session.commit()
PARADM000_id = PARADM000.id
instrument_name_FLORD = Instrumentname()
instrument_name_FLORD.instrument_class = 'FLORD'
instrument_name_FLORD.display_name = '2-Wavelength Fluorometer'
instrument_name_FLORD.id = 18
db.session.add(instrument_name_FLORD)
db.session.commit()
instrument_name_PARAD = Instrumentname()
instrument_name_PARAD.instrument_class = 'PARAD'
instrument_name_PARAD.display_name = 'Photosynthetically Available Radiation'
instrument_name_PARAD.id = 34
db.session.add(instrument_name_PARAD)
db.session.commit()
#TODO
# Scenario:
# Verify exists: (1) one platform_deployment; (2) two instrument deployments and the
# todo (3) two instrument deployments are properly formed in platform deployment
# delete first instrument deployment, verify success
# verify platform deployment has only one instrument deployment (checks model foreign key usage)
# delete remaining instrument deployment
# check platform_deployment exists and has no instrument deployments
# Get all platform deployments; verify platform deployment count
response = self.client.get(url_for('main.get_platform_deployments'),
content_type=content_type)
self.assertTrue(response.status_code == 200)
# Verify number of platform deployments
all_pd_data = json.loads(response.data)
self.assertIn('platform_deployments', all_pd_data)
list_all_pd_data = all_pd_data['platform_deployments']
len_list_all_pd_data = len(list_all_pd_data)
self.assertTrue(len_list_all_pd_data > 0)
self.assertEquals(len_list_all_pd_data, number_of_platform_deployments)
# Verify number of instruments for platform deployment GS05MOAS_PG002
response = self.client.get(
'/instrument_deployment?platform_deployment_id=%d' %
GS05MOAS_PG002_id)
self.assertTrue(response.status_code == 200)
# Verify result has instrument_deployments and number of instrument_deployments is correct
response_data = json.loads(response.data[:])
self.assertIn('instrument_deployments', response_data)
list_instrument_deployments = response_data['instrument_deployments']
len_list_instrument_deployments = len(list_instrument_deployments)
self.assertEquals(number_of_instruments,
len_list_instrument_deployments)
# TODO Verify instrument_deployments are properly formed and valid for this platform deployment (GS05MOAS_PG002)
# Check number of instrument deployments and verify display_name not None
# Verify for each instrument return by platform id (GS05MOAS_PG002_id), the display name
# is equal to display name returned from Instrumentname based on instrument class
check_instrument_deployment_display_names = 0
for instrument_deployment in list_instrument_deployments:
self.assertIn('display_name', instrument_deployment)
self.assertIn('id', instrument_deployment)
self.assertTrue(instrument_deployment['id'] != None)
self.assertTrue(instrument_deployment['id'] > 0)
display_name = instrument_deployment['display_name']
instrument_class = instrument_deployment['reference_designator'][
18:23]
foo = Instrumentname.query.filter(
Instrumentname.instrument_class == instrument_class).first()
_display_name = foo.display_name
self.assertTrue(_display_name != None)
self.assertEquals(display_name, _display_name)
check_instrument_deployment_display_names += 1
self.assertEquals(check_instrument_deployment_display_names,
number_of_instruments)
# Get all instrument deployments; verify instrument deployment count
response = self.client.get(url_for('main.get_instrument_deployments'),
content_type=content_type)
self.assertTrue(response.status_code == 200)
all_data = json.loads(response.data)
self.assertIn('instrument_deployments', all_data)
list_all_data = all_data['instrument_deployments']
len_list_all_data = len(list_all_data)
self.assertTrue(len_list_all_data > 0)
self.assertEquals(len_list_all_data, number_of_instruments)
# Delete instrument deployment FLORDM000
response = self.client.delete(url_for(
'main.delete_instrument_deployment', id=FLORDM000_id),
headers=headers)
self.assertEquals(response.status_code, 200)
# Now verify list of instruments for platform deployments reflects deleted instrument deployment
response = self.client.get(
'/instrument_deployment?platform_deployment_id=%d' %
GS05MOAS_PG002_id)
self.assertTrue(response.status_code == 200)
# Verify number of instruments for platform deployment GS05MOAS_PG002 is one less than number_of_instruments
response_data = json.loads(response.data[:])
self.assertIn('instrument_deployments', response_data)
curr_list_instrument_deployments = response_data[
'instrument_deployments']
#len_curr_list_instrument_deployments = len(curr_list_instrument_deployments)
self.assertEquals((number_of_instruments - 1),
len(curr_list_instrument_deployments))
# Delete instrument deployment PARADM000
response = self.client.delete(url_for(
'main.delete_instrument_deployment', id=PARADM000_id),
headers=headers)
self.assertEquals(response.status_code, 200)
# Now verify list of instruments for platform deployments reflects deleted instrument deployment
response = self.client.get(
'/instrument_deployment?platform_deployment_id=%d' %
GS05MOAS_PG002_id)
self.assertTrue(response.status_code == 200)
# Verify no instruments for platform deployment GS05MOAS_PG002
expected_empty_response_data = {"instrument_deployments": []}
response_data = json.loads(response.data[:])
self.assertIn('instrument_deployments', response_data)
curr_list_instrument_deployments = response_data[
'instrument_deployments']
len_curr_list_instrument_deployments = len(
curr_list_instrument_deployments)
self.assertEquals((number_of_instruments - 2),
len_curr_list_instrument_deployments)
self.assertEquals(response_data, expected_empty_response_data)
def test_route_get_instrument_deployments(self):
content_type = 'application/json'
# Create a sample data set:
# Summary: 2 platform deployments, three instrument deployments
# Contents:
# 1. platform deployment: CE04OSSM-SBD11
# instrument deployment(1): CE04OSSM-SBD11-01-MOPAK0000
#
# 2. platform deployment: GS05MOAS-PG002
# instrument deployment(1): GS05MOAS-PG002-02-FLORDM000
# instrument deployment(2): GS05MOAS-PG002-04-PARADM000
#
# platform_deployment(s) - CE04OSSM-SBD11, GS05MOAS-PG002
# platform deployment 1
CE04OSSM_SBD11_rd = 'CE04OSSM-SBD11'
CE04OSSM_SBD11 = PlatformDeployment(
reference_designator=CE04OSSM_SBD11_rd)
db.session.add(CE04OSSM_SBD11)
db.session.commit()
CE04OSSM_SBD11_id = CE04OSSM_SBD11.id
# platform deployment 2
GS05MOAS_PG002_rd = 'GS05MOAS-PG002'
GS05MOAS_PG002 = PlatformDeployment(
reference_designator=GS05MOAS_PG002_rd)
db.session.add(GS05MOAS_PG002)
db.session.commit()
GS05MOAS_PG002_id = GS05MOAS_PG002.id
# Create multiple instrument deployments for multiple platforms
# instrument deployment 1 (platform deployment 1)
number_of_instruments = 3
MOPAK0000_rd = 'CE04OSSM-SBD11-01-MOPAK0000'
MOPAK0000 = InstrumentDeployment(reference_designator=MOPAK0000_rd)
# todo get remaining data for this instrument
db.session.add(MOPAK0000)
db.session.commit()
MOPAK0000_id = MOPAK0000.id
# instrument deployment 2 (platform deployment 2 - first instrument)
FLORDM000_rd = 'GS05MOAS-PG002-02-FLORDM000'
FLORDM000 = InstrumentDeployment(reference_designator=FLORDM000_rd)
FLORDM000.depth = 1000.0
FLORDM000.display_name = '2-Wavelength Fluorometer'
FLORDM000.end_date = dt.datetime.now()
FLORDM000.geo_location = 'POINT(-70 40)'
FLORDM000.platform_deployment_id = GS05MOAS_PG002_id # actual 754
FLORDM000.reference_designator = FLORDM000_rd
FLORDM000.start_date = dt.datetime.now()
db.session.add(FLORDM000)
db.session.commit()
FLORDM000_id = FLORDM000.id
# instrument deployment 3 (platform deployment 2 - second instrument)
PARADM000_rd = 'GS05MOAS-PG002-04-PARADM000'
PARADM000 = InstrumentDeployment(reference_designator=PARADM000_rd)
PARADM000.depth = 1000.0
PARADM000.display_name = 'Photosynthetically Available Radiation'
PARADM000.end_date = dt.datetime.now()
PARADM000.geo_location = 'POINT(-70 40)'
PARADM000.platform_deployment_id = GS05MOAS_PG002_id # actual 774
PARADM000.reference_designator = PARADM000_rd
PARADM000.start_date = dt.datetime.now()
db.session.add(PARADM000)
db.session.commit()
PARADM000_id = PARADM000.id
# Get all instrument deployments; verify 3 instruments returned
response = self.client.get(url_for('main.get_instrument_deployments'),
content_type=content_type)
self.assertTrue(response.status_code == 200)
all_data = json.loads(response.data)
# Verify three instruments
self.assertIn('instrument_deployments', all_data)
list_all_data = all_data['instrument_deployments']
len_list_all_data = len(list_all_data)
self.assertTrue(len_list_all_data > 0)
self.assertEquals(len_list_all_data, number_of_instruments)
# todo Verify each instrument is associated with correct platform deployment id
# Get instrument MOPAK0000
response = self.client.get(url_for('main.get_instrument_deployment',
id=MOPAK0000_id),
content_type=content_type)
self.assertTrue(response.status_code == 200)
MOPAK0000_data = json.loads(response.data[:])
# todo Verify (a) all required fields provided, (b)content as expected and (c) geo_location not null
# Get instrument FLORDM000
response = self.client.get(url_for('main.get_instrument_deployment',
id=FLORDM000_id),
content_type=content_type)
self.assertTrue(response.status_code == 200)
FLORDM000_data = json.loads(response.data[:])
# todo Verify (a) all required fields provided, (b)content as expected and (c) geo_location not null
# Get instrument PARADM000
response = self.client.get(url_for('main.get_instrument_deployment',
id=PARADM000_id),
content_type=content_type)
self.assertTrue(response.status_code == 200)
PARADM000_data = json.loads(response.data[:])
# todo Verify (a) all required fields provided, (b)content as expected and (c) geo_location not null
response = self.client.get(
'/instrument_deployment?platform_deployment_id=%s' %
GS05MOAS_PG002_id)
self.assertTrue(response.status_code == 200)
response_data = response.data
self.assertTrue(
self._check_instrument_deployment_fields_provided(response_data))
if 'instrument_deployments' in response_data:
ins_data = json.loads(response_data)
list_instrument_deployment = ins_data['instrument_deployments']
self.assertEquals(list_instrument_deployment[0], FLORDM000_data)
self.assertEquals(response.status_code, 200)
def get_svg_plot(instrument, stream):
# from ooiservices.app.uframe.controller import split_stream_name
# Ok first make a list out of stream and instrument
instrument = instrument.split(',')
#instrument.append(instrument[0])
stream = stream.split(',')
#stream.append(stream[0])
plot_format = request.args.get('format', 'svg')
# time series vs profile
plot_layout = request.args.get('plotLayout', 'timeseries')
xvar = request.args.get('xvar', 'time')
yvar = request.args.get('yvar', None)
# There can be multiple variables so get into a list
xvar = xvar.split(',')
yvar = yvar.split(',')
if len(instrument) == len(stream):
pass # everything the same
else:
instrument = [instrument[0]]
stream = [stream[0]]
yvar = [yvar[0]]
xvar = [xvar[0]]
# create bool from request
# use_line = to_bool(request.args.get('line', True))
use_scatter = to_bool(request.args.get('scatter', True))
use_event = to_bool(request.args.get('event', True))
qaqc = int(request.args.get('qaqc', 0))
# Get Events!
events = {}
if use_event:
try:
response = _get_events_by_ref_des(instrument[0])
events = json.loads(response.data)
except Exception as err:
current_app.logger.exception(str(err.message))
return jsonify(error=str(err.message)), 400
profileid = request.args.get('profileId', None)
# need a yvar for sure
if yvar is None:
return jsonify(error='Error: yvar is required'), 400
height = float(request.args.get('height', 100)) # px
width = float(request.args.get('width', 100)) # px
# do conversion of the data from pixels to inches for plot
height_in = height / 96.
width_in = width / 96.
# get the data from uFrame
try:
if plot_layout == "depthprofile":
data = get_process_profile_data(stream[0], instrument[0], yvar[0],
xvar[0])
else:
if len(instrument) == 1:
data = get_data(stream[0], instrument[0], yvar, xvar)
elif len(instrument) > 1: # Multiple datasets
data = []
for idx, instr in enumerate(instrument):
stream_data = get_data(stream[idx], instr, [yvar[idx]],
[xvar[idx]])
data.append(stream_data)
except Exception as err:
current_app.logger.exception(str(err.message))
return jsonify(error=str(err.message)), 400
if not data:
return jsonify(error='No data returned for %s' % plot_layout), 400
# return if error
if 'error' in data or 'Error' in data:
return jsonify(error=data['error']), 400
# generate plot
some_tuple = ('a', 'b')
if str(type(data)) == str(
type(some_tuple)) and plot_layout == "depthprofile":
return jsonify(error='tuple data returned for %s' % plot_layout), 400
if isinstance(data, dict):
# get title
title = PlatformDeployment._get_display_name(instrument[0])
if len(title) > 50:
title = ''.join(
title.split('-')[0:-1]) + '\n' + title.split('-')[-1]
data['title'] = title
data['height'] = height_in
data['width'] = width_in
else:
for idx, streamx in enumerate(stream):
title = PlatformDeployment._get_display_name(instrument[idx])
if len(title) > 50:
title = ''.join(
title.split('-')[0:-1]) + '\n' + title.split('-')[-1]
data[idx]['title'] = title
data[idx]['height'] = height_in
data[idx]['width'] = width_in
plot_options = {
'plot_format': plot_format,
'plot_layout': plot_layout,
'use_scatter': use_scatter,
'events': events,
'profileid': profileid,
'width_in': width_in,
'use_qaqc': qaqc,
'st_date': request.args['startdate'],
'ed_date': request.args['enddate']
}
try:
buf = generate_plot(data, plot_options)
content_header_map = {'svg': 'image/svg+xml', 'png': 'image/png'}
return buf.read(), 200, {
'Content-Type': content_header_map[plot_format]
}
except Exception as err:
current_app.logger.exception(str(err.message))
return jsonify(error='Error generating {0} plot: {1}'.format(
plot_options['plot_layout'], str(err.message))), 400
def get_svg_plot(instrument, stream):
# from ooiservices.app.uframe.controller import split_stream_name
# Ok first make a list out of stream and instrument
instrument = instrument.split(',')
#instrument.append(instrument[0])
stream = stream.split(',')
#stream.append(stream[0])
plot_format = request.args.get('format', 'svg')
# time series vs profile
plot_layout = request.args.get('plotLayout', 'timeseries')
xvar = request.args.get('xvar', 'time')
yvar = request.args.get('yvar', None)
# There can be multiple variables so get into a list
xvar = xvar.split(',')
yvar = yvar.split(',')
if len(instrument) == len(stream):
pass # everything the same
else:
instrument = [instrument[0]]
stream = [stream[0]]
yvar = [yvar[0]]
xvar = [xvar[0]]
# create bool from request
# use_line = to_bool(request.args.get('line', True))
use_scatter = to_bool(request.args.get('scatter', True))
use_event = to_bool(request.args.get('event', True))
qaqc = int(request.args.get('qaqc', 0))
# Get Events!
events = {}
if use_event:
try:
response = _get_events_by_ref_des(instrument[0])
events = json.loads(response.data)
except Exception as err:
current_app.logger.exception(str(err.message))
return jsonify(error=str(err.message)), 400
profileid = request.args.get('profileId', None)
# need a yvar for sure
if yvar is None:
return jsonify(error='Error: yvar is required'), 400
height = float(request.args.get('height', 100)) # px
width = float(request.args.get('width', 100)) # px
# do conversion of the data from pixels to inches for plot
height_in = height / 96.
width_in = width / 96.
# get the data from uFrame
try:
if plot_layout == "depthprofile":
data = get_process_profile_data(stream[0], instrument[0], yvar[0], xvar[0])
else:
if len(instrument) == 1:
data = get_data(stream[0], instrument[0], yvar, xvar)
elif len(instrument) > 1: # Multiple datasets
data = []
for idx, instr in enumerate(instrument):
stream_data = get_data(stream[idx], instr, [yvar[idx]], [xvar[idx]])
data.append(stream_data)
except Exception as err:
current_app.logger.exception(str(err.message))
return jsonify(error=str(err.message)), 400
if not data:
return jsonify(error='No data returned for %s' % plot_layout), 400
# return if error
if 'error' in data or 'Error' in data:
return jsonify(error=data['error']), 400
# generate plot
some_tuple = ('a', 'b')
if str(type(data)) == str(type(some_tuple)) and plot_layout == "depthprofile":
return jsonify(error='tuple data returned for %s' % plot_layout), 400
if isinstance(data, dict):
# get title
title = PlatformDeployment._get_display_name(instrument[0])
if len(title) > 50:
title = ''.join(title.split('-')[0:-1]) + '\n' + title.split('-')[-1]
data['title'] = title
data['height'] = height_in
data['width'] = width_in
else:
for idx, streamx in enumerate(stream):
title = PlatformDeployment._get_display_name(instrument[idx])
if len(title) > 50:
title = ''.join(title.split('-')[0:-1]) + '\n' + title.split('-')[-1]
data[idx]['title'] = title
data[idx]['height'] = height_in
data[idx]['width'] = width_in
plot_options = {'plot_format': plot_format,
'plot_layout': plot_layout,
'use_scatter': use_scatter,
'events': events,
'profileid': profileid,
'width_in': width_in,
'use_qaqc': qaqc,
'st_date': request.args['startdate'],
'ed_date': request.args['enddate']}
try:
buf = generate_plot(data, plot_options)
content_header_map = {
'svg' : 'image/svg+xml',
'png' : 'image/png'
}
return buf.read(), 200, {'Content-Type': content_header_map[plot_format]}
except Exception as err:
current_app.logger.exception(str(err.message))
return jsonify(error='Error generating {0} plot: {1}'.format(plot_options['plot_layout'], str(err.message))), 400
