def storeLogs(telemetry, drone_name):
global drone_elapsed_time, drone_telemetry, drone_storage
telemetry = exceptions.checkVariable_helper(telemetry, dict)
drone_name = exceptions.checkVariable_helper(drone_name, str)
if drone_elapsed_time is None:
drone_elapsed_time = time.time()
if drone_name not in drone_storage:
qhawax_id = (
same_helper.getQhawaxID(drone_name)
if same_helper.getQhawaxID(drone_name) is not None
else "qH001"
)
drone_storage[drone_name] = qhawax_id
if time.time() - drone_elapsed_time > MAX_SECONDS_DATA_STORAGE:
drone_telemetry = formatTelemetryForStorage(telemetry)
drone_telemetry["timestamp"] = datetime.datetime.now(
dateutil.tz.tzutc()
)
drone_telemetry["qhawax_id"] = drone_storage[drone_name]
drone_telemetry = DroneTelemetry(**drone_telemetry)
session.add(drone_telemetry)
session.commit()
drone_elapsed_time = time.time()
def saveStatusQhawaxTable(qhawax_name, qhawax_status, main_inca):
"""Set qHAWAX ON or OFF in qHAWAX table"""
main_inca = exceptions.checkVariable_helper(main_inca, int)
qhawax_status = exceptions.checkVariable_helper(qhawax_status, str)
qhawax_json_status = {"state": qhawax_status, "main_inca": main_inca}
same_helper.qhawaxQueryUpdateFilterByQhawaxName(qhawax_json_status,
qhawax_name)
def validAndBeautyJsonValidProcessed(data_json, product_id, inca_value):
"""Helper function to valid json Valid Processed table"""
data_json = exceptions.checkVariable_helper(data_json, dict)
product_id = exceptions.checkVariable_helper(product_id, str)
storeValidProcessedDataInDB(data_json, product_id)
if inca_value == 0.0:
post_business_helper.updateMainIncaQhawaxTable(1, product_id)
post_business_helper.updateMainIncaQhawaxInstallationTable(
1, product_id
)
def validAndBeautyJsonValidProcessedMobile(data_json, product_id):
data_json = exceptions.checkVariable_helper(data_json, dict)
product_id = exceptions.checkVariable_helper(product_id, str)
if util_helper.checkValidLatLonValues(data_json):
if not (
same_helper.isMobileQhawaxInATrip(product_id)
): # in case trip has finished, a new one has to begin...
recordStartTrip(product_id)
storeValidProcessedDataInDBMobile(data_json, product_id)
max_value = 0
for i in range(len(pollutants)):
socket_name = data_json["ID"] + "_" + str(pollutants[i]) + "_valid"
pollutantStr = (
str(pollutants[i]) + "_ug_m3"
if (pollutants[i] in ["CO", "NO2", "O3", "H2S", "SO2"])
else str(pollutants[i])
)
new_data_json = {
"sensor": pollutants[i],
"center": {"lat": data_json["lat"], "lng": data_json["lon"]},
}
factor_final_json = {
"CO": 100 / 10000,
"NO2": 100 / 200,
"PM10": 100 / 150,
"PM25": 100 / 25,
"SO2": 100 / 20,
"O3": 100 / 100,
"H2S": 100 / 150,
}
if data_json[pollutantStr] != None:
if pollutants[i] in factor_final_json:
data_json[pollutantStr] = round(
data_json[pollutantStr]
* factor_final_json[pollutants[i]],
3,
)
new_data_json[pollutants[i]] = data_json[pollutantStr]
socketio.emit(socket_name, new_data_json) # qH006_CO_valid
if (
data_json[pollutantStr] >= max_value
): # same percentage comparison logic to obtain the highest percentage out of all pollutants
max_value = data_json[pollutantStr]
sensor_name = pollutants[i]
calInca = util_helper.validaPollutant(max_value, sensor_name)
post_business_helper.updateMainIncaQhawaxTable(calInca, product_id)
post_business_helper.updateMainIncaQhawaxInstallationTable(
calInca, product_id
)
def checkNumberValues(data_json):
"""Helper Processed Measurement function to check number values"""
data_json = exceptions.checkVariable_helper(data_json, dict)
for i in range(len(array_ppb)):
if data_json[array_ppb[i]] == "Nan":
data_json[array_ppb[i]] = 0
return data_json
def roundUpThree(data_json):
data_json = exceptions.checkVariable_helper(data_json, dict)
for i in range(len(array_ug_m3)):
if (type(data_json[array_ug_m3[i]]) is float) or (type(
data_json[array_ug_m3[i]]) is int):
data_json[array_ug_m3[i]] = round(data_json[array_ug_m3[i]], 3)
return data_json
def companyExistBasedOnRUC(ruc):
"""Helper function to check if company name exist"""
ruc = exceptions.checkVariable_helper(ruc, str)
company_list = session.query(Company.ruc).filter_by(ruc=ruc).all()
if company_list == []:
return False
return True
def areFieldsValid(data):
data = exceptions.checkVariable_helper(data, dict)
for i in range(len(array_installation)):
if (data[array_installation[i]] == ""
or data[array_installation[i]] == None):
return False
return True
def setNoneStringElements(data_json):
string_fields = ["ID", "timestamp_zone", "timestamp", "zone"]
data_json = exceptions.checkVariable_helper(data_json, dict)
for key in data_json:
if (type(data_json[key]) is str) and (key not in string_fields):
data_json[key] = None
return data_json
def qhawaxExistBasedOnID(qhawax_id):
"""Helper function to check if qHAWAX id exist"""
qhawax_id = exceptions.checkVariable_helper(qhawax_id, int)
qhawax_list = session.query(Qhawax.name).filter_by(id=qhawax_id).all()
if qhawax_list == []:
return False
return True
def storeAirQualityDataInDB(data):
"""Helper function to record Air Quality measurement"""
data = exceptions.checkVariable_helper(data, dict)
qhawax_name = data.pop("ID", None)
qhawax_id = same_helper.getQhawaxID(qhawax_name)
if qhawax_id != None:
air_quality_data = {
"CO": data["CO"],
"CO_ug_m3": data["CO_ug_m3"],
"H2S": data["H2S"],
"H2S_ug_m3": data["H2S_ug_m3"],
"SO2": data["SO2"],
"SO2_ug_m3": data["SO2_ug_m3"],
"NO2": data["NO2"],
"NO2_ug_m3": data["NO2_ug_m3"],
"O3_ug_m3": data["O3_ug_m3"],
"PM25": data["PM25"],
"PM10": data["PM10"],
"O3": data["O3"],
"lat": data["lat"],
"lon": data["lon"],
"alt": data["alt"],
"uv": data["UV"],
"spl": data["SPL"],
"temperature": data["temperature"],
"timestamp_zone": data["timestamp_zone"],
"I_temperature": data["I_temperature"],
"humidity": data["humidity"],
"pressure": data["pressure"],
}
air_quality_measurement = AirQualityMeasurement(
**air_quality_data, qhawax_id=qhawax_id
)
session.add(air_quality_measurement)
session.commit()
def qhawaxExistBasedOnName(qhawax_name):
"""Helper function that checks if qHAWAX name exist"""
qhawax_name = exceptions.checkVariable_helper(qhawax_name, str)
qhawax_list = session.query(Qhawax.name).filter_by(name=qhawax_name).all()
if qhawax_list == []:
return False
return True
def createCompany(json_company):
"""Create a new company"""
json_company = exceptions.checkVariable_helper(json_company, dict)
company_name = json_company.pop("company_name", None)
json_company["name"] = company_name
company_var = Company(**json_company)
session.add(company_var)
session.commit()
def validTimeOfValidProcessed(
time_valid, time_type, last_time_turn_on, data_json, product_id, inca_value
):
"""Helper function to valid time of Valid Processed table"""
time_valid = exceptions.checkVariable_helper(time_valid, int)
time_type = exceptions.checkVariable_helper(time_type, str)
data_json = exceptions.checkVariable_helper(data_json, dict)
product_id = exceptions.checkVariable_helper(product_id, str)
aditional_time = (
datetime.timedelta(hours=time_valid)
if (time_type == "hour")
else datetime.timedelta(minutes=time_valid)
)
if last_time_turn_on + aditional_time < datetime.datetime.now(
dateutil.tz.tzutc()
):
validAndBeautyJsonValidProcessed(data_json, product_id, inca_value)
def areaExistBasedOnID(eca_noise_id):
"""Helper function to check if Area ID exist"""
eca_noise_id = exceptions.checkVariable_helper(eca_noise_id, int)
area_name = (session.query(
EcaNoise.area_name).filter_by(id=eca_noise_id).all())
if area_name == []:
return False
return True
def companyExistBasedOnName(company_name):
"""Helper function to check if company name exist"""
company_name = exceptions.checkVariable_helper(company_name, str)
company_list = (session.query(
Company.name).filter_by(name=company_name).all())
if company_list == []:
return False
return True
def isItFieldQhawax(qhawax_name):
"""Check qhawax in field"""
qhawax_type = exception_helper.checkVariable_helper(qhawax_name, str)
return (
True
if (same_helper.getInstallationIdBaseName(qhawax_name) is not None)
else False
)
def createQhawax(qhawax_name, qhawax_type):
"""Create a qHAWAX module"""
qhawax_name = exceptions.checkVariable_helper(qhawax_name, str)
qhawax_type = exceptions.checkVariable_helper(qhawax_type, str)
qhawax_data = {
"name": qhawax_name,
"qhawax_type": qhawax_type,
"state": "OFF",
"availability": "Available",
"main_aqi": -1.0,
"mode": "Stand By",
"on_loop": 0,
"main_inca": -1.0,
}
qhawax_data_var = Qhawax(**qhawax_data)
session.add(qhawax_data_var)
session.commit()
def storeProcessedDataInDB(data):
"""Helper Processed Measurement function to store Processed Data"""
data = exceptions.checkVariable_helper(data, dict)
qhawax_name = data.pop("ID", None)
qhawax_id = same_helper.getQhawaxID(qhawax_name)
processed_measurement = ProcessedMeasurement(**data, qhawax_id=qhawax_id)
session.add(processed_measurement)
session.commit()
def qhawaxInstallationExistBasedOnID(installation_id):
"""Helper function to check if qHAWAX Installation ID exist"""
installation_id = exceptions.checkVariable_helper(installation_id, int)
installation_date_zone = (session.query(
QhawaxInstallationHistory.installation_date_zone).filter_by(
id=installation_id).all())
if installation_date_zone == []:
return False
return True
def writeBinnacle(qhawax_name, description, person_in_charge):
"""Insert observations in Binnacle"""
description = exceptions.checkVariable_helper(description, str)
person_in_charge = exceptions.checkVariable_helper(person_in_charge, str)
qHAWAX_ID = same_helper.getQhawaxID(qhawax_name)
if qHAWAX_ID is not None:
now2 = datetime.datetime.now(dateutil.tz.tzutc())
bitacora = {
"timestamp_zone": now2,
"observation_type": "Interna",
"description": description,
"qhawax_id": qHAWAX_ID,
"solution": None,
"person_in_charge": person_in_charge,
"end_date_zone": None,
"start_date_zone": None,
}
bitacora_update = Bitacora(**bitacora)
session.add(bitacora_update)
session.commit()
def validAndBeautyJsonProcessed(data_json):
arr_season = [2.62, 1.88, 1.96, 1.15, 1.39] # Arreglo de 25C
data_json = exceptions.checkVariable_helper(data_json, dict)
if "timestamp_zone" not in data_json:
data_json["timestamp_zone"] = data_json["timestamp"]
data_json = gasConversionPPBtoMG(data_json, arr_season)
# Convertir los pascales a hectopascales
data_json["pressure"] = (float(data_json["pressure"]) * 0.01 if
(data_json["pressure"] != "Nan") else "Nan")
data_json = roundUpThree(data_json)
return data_json
def validTimeJsonProcessed(data_json):
data_json = exceptions.checkVariable_helper(data_json, dict)
datetime_array = data_json["timestamp"].split()
measurement_year = datetime.datetime.strptime(datetime_array[0],
"%Y-%m-%d").year
if measurement_year > datetime.date.today().year:
data_json["timestamp"] = (
datetime.datetime.now(dateutil.tz.tzutc()) -
datetime.timedelta(hours=5)).strftime("%Y-%m-%d %H:%M:%S")
data_json["timestamp_zone"] = (datetime.datetime.now(
dateutil.tz.tzutc())).strftime("%Y-%m-%d %H:%M:%S")
return data_json
def updateQhawaxInstallation(data):
"""Update qHAWAX in Field"""
data = exceptions.checkVariable_helper(data, dict)
if util_helper.areFieldsValid(data) == False:
raise Exception("qHAWAX Installation fields must have data")
data["qhawax_id"] = same_helper.getQhawaxID(data["qhawax_name"])
data.pop("qhawax_name", None)
session.query(QhawaxInstallationHistory).filter_by(
qhawax_id=data["qhawax_id"],
company_id=data["company_id"],
end_date_zone=None,
).update(values=data)
session.commit()
def queryQhawaxTypeInFieldInPublicMode(qhawax_type):
"""Get list of qHAWAXs in field in public mode based on qhawax type"""
qhawax_type = exception_helper.checkVariable_helper(qhawax_type, str)
qhawax_public = (
session.query(*columns_qhawax)
.join(EcaNoise, QhawaxInstallationHistory.eca_noise_id == EcaNoise.id)
.join(Qhawax, QhawaxInstallationHistory.qhawax_id == Qhawax.id)
.group_by(Qhawax.id, QhawaxInstallationHistory.id, EcaNoise.id)
.filter(
Qhawax.qhawax_type == qhawax_type,
QhawaxInstallationHistory.end_date_zone == None,
)
.order_by(Qhawax.id)
.all()
)
return [qhawax._asdict() for qhawax in qhawax_public]
def storeGasIncaInDB(data):
"""Helper function to record GAS INCA measurement"""
data = exceptions.checkVariable_helper(data, dict)
gas_inca_data = {
"CO": data["CO"],
"H2S": data["H2S"],
"SO2": data["SO2"],
"NO2": data["NO2"],
"timestamp_zone": data["timestamp_zone"],
"O3": data["O3"],
"PM25": data["PM25"],
"PM10": data["PM10"],
"main_inca": data["main_inca"],
}
qhawax_name = data.pop("ID", None)
qhawax_id = same_helper.getQhawaxID(qhawax_name)
gas_inca_processed = GasInca(**gas_inca_data, qhawax_id=qhawax_id)
session.add(gas_inca_processed)
session.commit()
def storeNewQhawaxInstallation(data):
"""Insert new qHAWAX in Field"""
data = exceptions.checkVariable_helper(data, dict)
if util_helper.areFieldsValid(data) == False:
raise Exception("qHAWAX Installation fields have to have data")
qhawax_id = same_helper.getQhawaxID(data["qhawax_name"])
if qhawax_id != None:
data["qhawax_id"] = int(qhawax_id)
data["main_inca"] = same_helper.getMainIncaQhawaxTable(
data["qhawax_name"])
data["installation_date_zone"] = data["instalation_date"]
data["last_time_physically_turn_on_zone"] = data["instalation_date"]
data.pop("instalation_date", None)
data.pop("qhawax_name", None)
if "id" in data:
data.pop("id", None)
if "company_name" in data:
data.pop("company_name", None)
qhawax_installation = QhawaxInstallationHistory(**data)
session.add(qhawax_installation)
session.commit()
def queryDBGasAverageMeasurement(qhawax_name, gas_name):
"""Helper function to get gas average measurement based on qHAWAX name and sensor name"""
gas_name = exceptions.checkVariable_helper(gas_name, str)
if gas_name not in sensor_array:
raise ValueError("Sensor name " + str(gas_name) +
" should be CO, H2S, NO2, O3, PM25, PM10 or SO2")
qhawax_id = same_helper.getQhawaxID(qhawax_name)
if qhawax_id != None:
initial_timestamp = datetime.datetime.now()
last_timestamp = datetime.datetime.now() - datetime.timedelta(hours=24)
column_array = [
AirQualityMeasurement.CO.label("sensor"),
AirQualityMeasurement.H2S.label("sensor"),
AirQualityMeasurement.NO2.label("sensor"),
AirQualityMeasurement.O3.label("sensor"),
AirQualityMeasurement.PM25.label("sensor"),
AirQualityMeasurement.PM10.label("sensor"),
AirQualityMeasurement.SO2.label("sensor"),
]
for i in range(len(sensor_array)):
if gas_name == sensor_array[i]:
sensors = (
AirQualityMeasurement.timestamp_zone,
column_array[i],
)
return (session.query(*sensors).filter(
AirQualityMeasurement.qhawax_id == qhawax_id).filter(
AirQualityMeasurement.timestamp_zone >= last_timestamp).filter(
AirQualityMeasurement.timestamp_zone <= initial_timestamp).
order_by(AirQualityMeasurement.timestamp_zone.asc()).all())
return None
def getFormatData(gas_average_measurement):
gas_average_measurement_list = []
if gas_average_measurement is not None:
data = exceptions.checkVariable_helper(gas_average_measurement, list)
next_hour = -1
for measurement in gas_average_measurement:
gas_measurement = measurement._asdict()
hour = gas_measurement["timestamp_zone"].hour
if next_hour == -1:
gas_average_measurement_list.append(gas_measurement)
next_hour = hour + 1
else:
if hour == next_hour:
gas_average_measurement_list.append(gas_measurement)
else:
if (next_hour > hour
): # si next_hour > hour => se resta con 24 horas
diff_0 = abs(24 - next_hour)
diff = diff_0 + hour
else:
diff = abs(hour - next_hour - 1)
for i in range(1, diff + 1):
new_variable = {
"timestamp_zone":
before_date + datetime.timedelta(hours=i),
"sensor":
"",
}
gas_average_measurement_list.append(new_variable)
gas_average_measurement_list.append(gas_measurement)
next_hour = hour + 1
before_date = gas_measurement["timestamp_zone"]
if next_hour == 24:
next_hour = 0
return gas_average_measurement_list
return None
def updateMainIncaQhawaxInstallationTable(new_main_inca, qhawax_name):
"""Helper qHAWAX function to save main inca value in qHAWAX Installation table"""
new_main_inca = exceptions.checkVariable_helper(new_main_inca, int)
qhawax_json_main_inca_installation = {"main_inca": new_main_inca}
same_helper.qhawaxInstallationQueryUpdate(
qhawax_json_main_inca_installation, qhawax_name)
