diff --git a/automatic_inclinometer/import_observations_wolfsegg_kb1.py b/automatic_inclinometer/import_observations_wolfsegg_kb1.py
new file mode 100644
index 0000000..a0d7cfb
--- /dev/null
+++ b/automatic_inclinometer/import_observations_wolfsegg_kb1.py
@@ -0,0 +1,197 @@
+""" import firebird, export to postgresql """
+#!/usr/bin/python# -*- coding: utf-8 -*-
+
+from typing import List
+import uuid
+from sqlalchemy.orm import session
+from sqlalchemy import desc, asc
+from db.fb_models import (create_session, FbObservation, Catena)
+from db.models import (create_pg_session, Dataset, Observation, Procedure, Phenomenon, Platform)
+
+def main():
+ """
+ Main function.
+ """
+
+ # parameter:
+ # sensor id in firebird db:
+ # sensor_id = 1
+ # # name of project area in firebird db
+ # feature_of_interest = 'TAC003-020-0517' # Wolfsegg KB1
+ # # sensor name in postgis db
+ # sensor = 'wolfsegg_kb1_1'
+ # platform = 'wolfsegg'
+
+ sensor_id = 0
+ # name of project area in firebird db
+ feature_of_interest = 'TAC003-020-0517' # Wolfsegg KB1
+ # sensor name in postgis db
+ sensor = 'wolfsegg_kb1_0'
+ platform = 'wolfsegg'
+
+ firebird_session: session = create_session()
+ # db_observation = session.query(Observation) \
+ # .filter_by(name='John Snow').first()
+ query = firebird_session.query(FbObservation).join(FbObservation.catena) \
+ .filter(FbObservation.sensore == sensor_id) \
+ .filter(Catena.name == feature_of_interest)
+ # feature_of_interest = query.statement.compile(dialect=firebird.dialect())
+ firebird_observations: List[FbObservation] = query.all()
+ firebird_session.close()
+
+ pg_session: session = create_pg_session()
+ # pg_datasets: List[Dataset] = pg_query.all()
+ pg_query = pg_session.query(Dataset) \
+ .join(Procedure) \
+ .join(Phenomenon) \
+ .filter(Procedure.sta_identifier == sensor.lower())
+ # .join(Platform).all() \
+
+
+ # roll_dataset = [x for x in pg_datasets if x.phenomenon.sta_identifier == "Roll"]
+ roll_dataset = pg_query.filter(Phenomenon.sta_identifier == "Roll").first()
+ roll_dataset.is_published = 1
+ roll_dataset.is_hidden = 0
+ roll_dataset.dataset_type = "timeseries"
+ roll_dataset.observation_type = "simple"
+ roll_dataset.value_type = "quantity"
+ slope_dataset = pg_query.filter(
+ Phenomenon.sta_identifier == "Slope").first()
+ slope_dataset.is_published = 1
+ slope_dataset.is_hidden = 0
+ slope_dataset.dataset_type = "timeseries"
+ slope_dataset.observation_type = "simple"
+ slope_dataset.value_type = "quantity"
+ temperature_dataset = pg_query.filter(
+ Phenomenon.sta_identifier == "InSystemTemperature").first()
+ temperature_dataset.is_published = 1
+ temperature_dataset.is_hidden = 0
+ temperature_dataset.dataset_type = "timeseries"
+ temperature_dataset.observation_type = "simple"
+ temperature_dataset.value_type = "quantity"
+ pg_session.commit()
+
+ # max_id = pg_session.query(func.max(Observation.id)).scalar()
+ for fb_observation in firebird_observations:
+ # print(fb_observation.catena.name)
+ if(fb_observation.roll is not None and roll_dataset is not None):
+ # max_id = max_id + 1
+ pg_roll_observation = Observation(
+ # id=max_id,
+ value_type='quantity',
+ sampling_time_start=fb_observation.result_time,
+ sampling_time_end=fb_observation.result_time,
+ result_time=fb_observation.result_time,
+ sta_identifier=str(uuid.uuid4()),
+ value_quantity=fb_observation.roll
+ )
+ roll_dataset.observations.append(pg_roll_observation)
+ if(fb_observation.pitch is not None and slope_dataset is not None):
+ # max_id = max_id + 1
+ pg_slope_observation = Observation(
+ # id=max_id,
+ value_type='quantity',
+ sampling_time_start=fb_observation.result_time,
+ sampling_time_end=fb_observation.result_time,
+ result_time=fb_observation.result_time,
+ sta_identifier=str(uuid.uuid4()),
+ value_quantity=fb_observation.pitch
+ )
+ slope_dataset.observations.append(pg_slope_observation)
+ if(fb_observation.temperature is not None and temperature_dataset is not None):
+ # max_id = max_id + 1
+ pg_temperature_observation = Observation(
+ # id=max_id,
+ value_type='quantity',
+ sampling_time_start=fb_observation.result_time,
+ sampling_time_end=fb_observation.result_time,
+ result_time=fb_observation.result_time,
+ sta_identifier=str(uuid.uuid4()),
+ value_quantity=fb_observation.temperature
+ )
+ temperature_dataset.observations.append(pg_temperature_observation)
+ # commit observations:
+ pg_session.commit()
+
+ last_roll_observation = pg_session.query(Observation) \
+ .filter(Observation.fk_dataset_id == roll_dataset.id) \
+ .order_by(desc('sampling_time_start')) \
+ .first()
+ if last_roll_observation is not None:
+ roll_dataset.last_time = last_roll_observation.sampling_time_start
+ roll_dataset.last_value = last_roll_observation.value_quantity
+ roll_dataset.fk_last_observation_id = last_roll_observation.id
+
+ last_slope_observation = pg_session.query(Observation) \
+ .filter(Observation.fk_dataset_id == slope_dataset.id) \
+ .order_by(desc('sampling_time_start')) \
+ .first()
+ if last_slope_observation is not None:
+ slope_dataset.last_time = last_slope_observation.sampling_time_start
+ slope_dataset.last_value = last_slope_observation.value_quantity
+ slope_dataset.fk_last_observation_id = last_slope_observation.id
+
+ last_temperature_observation = pg_session.query(Observation) \
+ .filter(Observation.fk_dataset_id == temperature_dataset.id) \
+ .order_by(desc('sampling_time_start')) \
+ .first()
+ if last_temperature_observation is not None:
+ temperature_dataset.last_time = last_temperature_observation.sampling_time_start
+ temperature_dataset.last_value = last_temperature_observation.value_quantity
+ temperature_dataset.fk_last_observation_id = last_temperature_observation.id
+
+ first_roll_observation = pg_session.query(Observation) \
+ .filter(Observation.fk_dataset_id == roll_dataset.id) \
+ .order_by(asc('sampling_time_start')) \
+ .first()
+ if first_roll_observation is not None:
+ roll_dataset.first_time = first_roll_observation.sampling_time_start
+ roll_dataset.first_value = first_roll_observation.value_quantity
+ roll_dataset.fk_first_observation_id = first_roll_observation.id
+
+ first_slope_observation = pg_session.query(Observation) \
+ .filter(Observation.fk_dataset_id == slope_dataset.id) \
+ .order_by(asc('sampling_time_start')) \
+ .first()
+ if first_slope_observation is not None:
+ slope_dataset.first_time = first_slope_observation.sampling_time_start
+ slope_dataset.first_value = first_slope_observation.value_quantity
+ slope_dataset.fk_first_observation_id = first_slope_observation.id
+
+ first_temperature_observation = pg_session.query(Observation) \
+ .filter(Observation.fk_dataset_id == temperature_dataset.id) \
+ .order_by(asc('sampling_time_start')) \
+ .first()
+ if first_temperature_observation is not None:
+ temperature_dataset.first_time = first_temperature_observation.sampling_time_start
+ temperature_dataset.first_value = first_temperature_observation.value_quantity
+ temperature_dataset.fk_first_observation_id = first_temperature_observation.id
+
+ platform_exists = pg_session.query(Platform.id).filter_by(
+ name=platform.lower()).scalar() is not None
+ if not platform_exists:
+ sensor_platform = Platform()
+ # max_id = pg_session.query(func.max(Platform.id)).scalar()
+ # sensor_platform.id = max_id + 1
+ sensor_platform.sta_identifier = platform.lower()
+ sensor_platform.identifier = platform.lower()
+ sensor_platform.name = platform.lower()
+ slope_dataset.platform = sensor_platform
+ roll_dataset.platform = sensor_platform
+ temperature_dataset.platform = sensor_platform
+ else:
+ sensor_platform = pg_session.query(Platform.id) \
+ .filter(Platform.name == platform.lower()) \
+ .first()
+ slope_dataset.fk_platform_id = sensor_platform.id
+ roll_dataset.fk_platform_id = sensor_platform.id
+ temperature_dataset.fk_platform_id = sensor_platform.id
+
+ # commit dataset changes:
+ pg_session.commit()
+ pg_session.close()
+
+
+# -----------------------------------------------------------------------------
+if __name__ == "__main__":
+ main()
diff --git a/automatic_inclinometer/insert_sensors/InsertSensorInclinometer.xml b/automatic_inclinometer/insert_sensors/InsertSensorInclinometer.xml
new file mode 100644
index 0000000..3749694
--- /dev/null
+++ b/automatic_inclinometer/insert_sensors/InsertSensorInclinometer.xml
@@ -0,0 +1,113 @@
+
+ {procedure_identifier}
+
+
+
+
+ longName
+ {procedure_name}
+
+
+
+
+ shortName
+ {procedure_name}
+
+
+
+
+
+
+
+
+ {offering_label}
+ {offering_name}
+
+
+
+
+
+
+
+
+ true
+
+
+
+
+ false
+
+
+
+
+
+
+ featuresOfInterest
+
+
+ {feature_id}
+ {feature_name}
+
+
+
+
+ {coordinates}
+
+
+
+
+
+
+
+
+
+
+ Slope
+
+
+
+
+
+ Roll
+
+
+
+
+
+ InSystemTemperature
+
+
+
+
+
+
+
+
+
+
+ {cord_x}
+
+
+
+
+
+ {cord_y}
+
+
+
+
+
+ {height}
+
+
+
+
+
\ No newline at end of file
diff --git a/automatic_inclinometer/insert_sensors/import_sensors_wolfsegg.py b/automatic_inclinometer/insert_sensors/import_sensors_wolfsegg.py
new file mode 100644
index 0000000..d0e0a67
--- /dev/null
+++ b/automatic_inclinometer/insert_sensors/import_sensors_wolfsegg.py
@@ -0,0 +1,227 @@
+# -*- coding: utf-8 -*-
+"""This module does blah blah."""
+
+from ast import List
+import requests
+# from insert_sensor.transactional import insert_sensor
+from insert_sensor.wrapper import (Offering, FoI, Procedure, SensorType)
+# import json
+
+
+class Sos():
+ """
+ A class to represent a sos service.
+ ...
+
+ Attributes
+ ----------
+ sosurl : str
+ first name of the person
+ token : str
+ token to access soso service
+ """
+
+ def __init__(self, url, token=''):
+ self.sosurl = str(url) # url to access the SOS
+ self.token = str(token) # security token, optional
+ # Test if URL exists
+ try:
+ test = requests.get(self.sosurl)
+ test.raise_for_status()
+ except requests.HTTPError:
+ print("The URL is not valid")
+
+# Python3 code here creating class
+
+
+class Sensor:
+ """
+ A class to represent an input sensor.
+ ...
+
+ Attributes
+ ----------
+ name : str
+ first name of the person
+ x : float
+ token to access soso service
+ y : float
+ token to access soso service
+ """
+
+ def __init__(self, name: str, x_coord: float, y_coord: float):
+ self.name = name
+ self.x_coord = x_coord
+ self.y_coord = y_coord
+
+
+def main():
+ """
+ main function
+ """
+ sos_url = 'https://geomon.geologie.ac.at/52n-sos-webapp/service'
+
+ # creating list
+ sensor_list: List[Sensor] = []
+
+ # appending instances to list
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_0', 13.808378638676, 47.882871028831))
+ # sensor_list.append(
+ # Sensor('wolfsegg_kb1_1', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_2', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_3', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_4', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_5', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_6', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_7', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_8', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_9', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_10', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_11', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_12', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_13', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_14', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_15', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_16', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_17', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_18', 13.808378638676, 47.882871028831))
+ sensor_list.append(
+ Sensor('wolfsegg_kb1_19', 13.808378638676, 47.882871028831))
+
+ sensor: Sensor
+ for sensor in sensor_list:
+ # platform wolfsegg
+ offering = Offering(
+ "https://geomon.geologie.ac.at/52n-sos-webapp/api/offerings/",
+ sensor.name,
+ "Bohrloch, Wolfsegg Inklinometer"
+ )
+ procedure = Procedure(sensor.name, sensor.name)
+ foi = FoI("degree", "m", (sensor.x_coord, sensor.y_coord, 0.0),
+ "TAC003-020-0517", "Wolfsegg KB1")
+ # now insert sensor via rest service:
+ sensor_type=SensorType("inclinometer")
+ post_data=insert_sensor(offering, procedure, foi, sensor_type)
+ # print(post_data)
+ headers={'Accept': 'application/json'}
+ request=requests.post(sos_url, headers = headers, json = post_data)
+ print(request.text)
+
+ # # platform Wolfsegg
+ # offering = Offering(
+ # "https://geomon.geologie.ac.at/52n-sos-webapp/api/offerings/",
+ # "wolfsegg_1",
+ # "Bohrloch, Wolfsegg Inklinometer"
+ # )
+ # procedure = Procedure("wolfsegg_1", "wolfsegg_1")
+ # foi = FoI("degree", "m", (13.6731638, 48.1064354, 0.0),
+ # "TAC003-020-0517", "Wolfsegg KB1")
+
+
+
+def insert_sensor(offering, procedure, foi, sensor_type):
+ """
+ Prepares the body of a InsertSensor request for JSON biding.
+ :param offering: an instance of class Offering.Type object.
+ :param Procedure: instance of class Procedure. type object.
+ :param foi: feature of interest. Instance of FoI
+ :param sensor_type: SensorType object
+ :return: valid body for an InsertSensor request.
+ """
+
+ # shortName = offering.name # string
+ # longName = 'Sibratsgfall test' # string
+
+ # Offering values
+ gml_id='\"' + str(procedure.id) + '\"' # Offering name, double quoted
+ offering_name=offering.name
+ offering_label=offering.label
+ # offID = offering.fullId # URL format of full id
+
+ # featureName = featureID = cordX = cordY = height = h_unit = z_unit = coordinates = ""
+ # check if feature of interest should be declare
+ if foi is not None:
+ # feature_id = 'https://geomon.geologie.ac.at/52n-sos-webapp/api/features/' + \
+ # str(foi.fid) # URL format
+ cord_x=str(foi.x) # longitude degrees, float
+ cord_y=str(foi.y) # latitude degrees, float
+ coordinates=cord_x + " " + cord_y
+ height=str(foi.z) # altitude in meters, float
+ # h_unit = foi.Hunit # units for horizontal coordinates
+ # z_unit = foi.Vunit # units for altitude
+ feature_id=foi.fid # "feature location"
+ feature_name=foi.name # "feature location"
+ else:
+ pass
+
+ procedure_name=procedure.name
+ procedure_identifier=procedure.id # URL,
+ obs_types=[]
+ output_list='' # output list element for describe procedure
+ properties_list=[]
+ for attr in sensor_type.pattern["attributes"]:
+ obs_prop_name='\"' + attr[0] + '\"' # attribute name
+ # print(obs_prop_name)
+ unit_name=sensor_type.om_types[attr[1]] # om type
+ # magnitud = a # ??
+
+ obs_name=obs_prop_name.replace('\"', '')
+ obs_name="".join(obs_name.split()) # observable property name
+ output=''
+ output_list=output_list + output
+ # add property identifier to the list.
+ properties_list.append(obs_name)
+ # prepare list of measurement types
+ # A sensor can not registry duplicated sensor types.
+ this_type="http://www.opengis.net/def/observationType/OGC-OM/2.0/"+unit_name
+ if this_type not in obs_types: # when new type appears
+ obs_types.append(this_type)
+ else:
+ continue
+
+ # Unit of measurement:
+ unit_name='\"' + procedure.name + '\"' # double quoted string
+ # unit = omType # one of the MO measurement types
+
+ body={
+ "request": "InsertSensor",
+ "service": "SOS",
+ "version": "2.0.0",
+ "procedureDescriptionFormat": "http://www.opengis.net/sensorml/2.0",
+ "procedureDescription": f'{procedure_identifier}longName{procedure_name}shortName{procedure_name}{offering_label}{offering_name}truefalsefeaturesOfInterest{feature_id}{feature_name}{coordinates}SlopeRollInSystemTemperature{cord_x}{cord_y}{height}',
+ "observableProperty": [
+ "Slope",
+ "Roll",
+ "InSystemTemperature"
+ ],
+ "observationType": [
+ "http://www.opengis.net/def/observationType/OGC-OM/2.0/OM_Measurement"
+ ],
+ "featureOfInterestType":
+ "http://www.opengis.net/def/samplingFeatureType/OGC-OM/2.0/SF_SamplingPoint"
+ }
+ return body
+
+
+if __name__ == '__main__':
+ main()
diff --git a/gschliefgraben_glasfaser/import_feature_sensor.py b/gschliefgraben_glasfaser/import_feature_sensor.py
index 95e7cc9..352fa54 100644
--- a/gschliefgraben_glasfaser/import_feature_sensor.py
+++ b/gschliefgraben_glasfaser/import_feature_sensor.py
@@ -174,7 +174,8 @@ def insert_sensor(offering, procedure, foi, sensor_type):
"observationType": [
"http://www.opengis.net/def/observationType/OGC-OM/2.0/OM_Measurement"
],
- "featureOfInterestType": "http://www.opengis.net/def/samplingFeatureType/OGC-OM/2.0/SF_SamplingPoint"
+ "featureOfInterestType":
+ "http://www.opengis.net/def/samplingFeatureType/OGC-OM/2.0/SF_SamplingPoint"
}
return body
diff --git a/gschliefgraben_piezometer/import_feature_sensor.py b/gschliefgraben_piezometer/import_feature_sensor.py
index e07df6c..d9573b4 100644
--- a/gschliefgraben_piezometer/import_feature_sensor.py
+++ b/gschliefgraben_piezometer/import_feature_sensor.py
@@ -48,7 +48,7 @@ def main():
# foi = FoI("degree", "m", (13.774966, 47.910849, 0.0),
# "bohrloch1-glasfaser-gschliefgraben",
# "Piezometer1 am Gschliefgraben")
-
+
# offering = Offering(
# "https://geomon.geologie.ac.at/52n-sos-webapp/api/offerings/",
# "bohrloch2",
@@ -58,7 +58,7 @@ def main():
# foi = FoI("degree", "m", (13.80957276439, 47.882524348741, 0.0),
# "bohrloch2-glasfaser-gschliefgraben",
# "Piezometer2 am Gschliefgraben")
-
+
# offering = Offering(
# "https://geomon.geologie.ac.at/52n-sos-webapp/api/offerings/",
# "bohrloch3",
@@ -68,7 +68,7 @@ def main():
# foi = FoI("degree", "m", (13.809990909737, 47.882824994038, 0.0),
# "bohrloch3-glasfaser-gschliefgraben",
# "Piezometer3 am Gschliefgraben")
-
+
# offering = Offering(
# "https://geomon.geologie.ac.at/52n-sos-webapp/api/offerings/",
# "bohrloch4",
@@ -78,7 +78,7 @@ def main():
# foi = FoI("degree", "m", (13.809379587392, 47.883098856837, 0.0),
# "bohrloch4-glasfaser-gschliefgraben",
# "Piezometer4 am Gschliefgraben")
-
+
# offering = Offering(
# "https://geomon.geologie.ac.at/52n-sos-webapp/api/offerings/",
# "bohrloch5",
@@ -88,7 +88,7 @@ def main():
# foi = FoI("degree", "m", (13.81120655331, 47.884145740545, 0.0),
# "bohrloch5-glasfaser-gschliefgraben",
# "Piezometer5 am Gschliefgraben")
-
+
offering = Offering(
"https://geomon.geologie.ac.at/52n-sos-webapp/api/offerings/",
"bohrloch6",
@@ -135,7 +135,8 @@ def insert_sensor(offering, procedure, foi, sensor_type):
# offID = offering.fullId # URL format of full id
# featureName = featureID = cordX = cordY = height = h_unit = z_unit = coordinates = ""
- if foi is not None: # check if feature of interest should be declare
+ # check if feature of interest should be declare
+ if foi is not None:
# feature_id = 'https://geomon.geologie.ac.at/52n-sos-webapp/api/features/' + \
# str(foi.fid) # URL format
cord_x = str(foi.x) # longitude degrees, float
diff --git a/gschliefgraben_piezometer/import_piezometer_observations_hourly.py b/gschliefgraben_piezometer/import_piezometer_observations_hourly.py
index ee2a345..86ec689 100644
--- a/gschliefgraben_piezometer/import_piezometer_observations_hourly.py
+++ b/gschliefgraben_piezometer/import_piezometer_observations_hourly.py
@@ -8,7 +8,7 @@ import os
import uuid
from datetime import datetime
from sqlalchemy.orm import session
-from sqlalchemy import asc, desc, func
+from sqlalchemy import asc, desc
from dotenv import load_dotenv, find_dotenv
import requests
from db.models import (
@@ -64,7 +64,7 @@ def main():
if not platform_exists:
sensor_platform = Platform()
- max_id = pg_session.query(func.max(Platform.id)).scalar()
+ # max_id = pg_session.query(func.max(Platform.id)).scalar()
# sensor_platform.id = max_id + 1
sensor_platform.sta_identifier = platform_sta_identifier.lower()
sensor_platform.identifier = platform_sta_identifier.lower()
diff --git a/insert_sensor/wrapper.py b/insert_sensor/wrapper.py
index c9274bd..fdc85a3 100644
--- a/insert_sensor/wrapper.py
+++ b/insert_sensor/wrapper.py
@@ -71,10 +71,10 @@ class SensorType:
("Battery level", "m"), ("Temperature", "m"), ("Relative humidity", "m")]}
elif type_ == "inclinometer": # INCLINOMETER
self.pattern = {"name": "inclinometer", "type": 'fixed', "attributes": [
- ("Slope", "deg"), ("Roll", "deg")]}
- elif type_ == "camera": # INCLINOMETER
+ ("Slope", "m"), ("Roll", "m"), ("Temperature", "m")]}
+ elif type_ == "camera": # Camera
self.pattern = {"name": "camera", "type": 'fixed', "attributes": [
- ("Image", "xo")]}
+ ("Image", "to")]}
elif type_ == "piezometer": # PIEZOMETER
self.pattern = {"name": "piezometer", "type": 'fixed', "attributes": [
("Elevation", "m")]}