def sendQhawaxStatusOff():
"""
Endpoint to set qHAWAX OFF because script detect no new data within five minutes
"""
jsonsend = {}
try:
req_json = request.get_json()
exception_helper.getStatusOffTargetofJson(req_json)
name = str(req_json['qhawax_name']).strip()
qhawax_time_off = req_json['qhawax_lost_timestamp']
description = req_json['description']
person_in_charge = req_json['person_in_charge']
post_business_helper.saveStatusOffQhawaxTable(name)
if (same_helper.getQhawaxMode(name) == 'Cliente'):
post_business_helper.saveStatusOffQhawaxInstallationTable(
name, qhawax_time_off)
post_business_helper.writeBinnacle(name, description, person_in_charge)
jsonsend['main_inca'] = -1
jsonsend['name'] = name
socketio.emit('update_inca', jsonsend)
return make_response({'Success': 'qHAWAX off'}, 200)
except (ValueError, TypeError) as e:
json_message = jsonify({'error': '\'%s\'' % (e)})
return make_response(json_message, 400)
def handleProcessedDataByQhawax():
"""
Records processed and valid processed measurements every five seconds
qHAWAX: Record new measurement
"""
flag_email = False
data_json = request.get_json()
try:
product_id = data_json['ID']
data_json = util_helper.validTimeJsonProcessed(data_json)
data_json = util_helper.validAndBeautyJsonProcessed(data_json)
post_data_helper.storeProcessedDataInDB(data_json)
data_json['ID'] = product_id
data_json['zone'] = "Undefined Zone"
mode = same_helper.getQhawaxMode(product_id)
inca_value = same_helper.getMainIncaQhawaxTable(product_id)
if (mode == "Customer" and inca_value != None):
data_json['zone'] = get_business_helper.getNoiseData(product_id)
minutes_difference, last_time_turn_on = get_business_helper.getHoursDifference(
product_id)
if (minutes_difference != None):
if (minutes_difference < 5):
post_data_helper.validTimeOfValidProcessed(
10, "minute", last_time_turn_on, data_json, product_id,
inca_value)
elif (minutes_difference >= 5):
post_data_helper.validTimeOfValidProcessed(
2, "hour", last_time_turn_on, data_json, product_id,
inca_value)
data_json = util_helper.setNoneStringElements(data_json)
socketio.emit(data_json['ID'] + '_processed', data_json)
return make_response('OK', 200)
except TypeError as e:
json_message = jsonify({'error': '\'%s\'' % (e)})
return make_response(json_message, 400)
def broadcast_winner(room, winner, scoreboard_info, gif):
socketio.emit('notify-winner', {
'msg': winner,
'scoreboard': scoreboard_info,
'winGif': gif
},
room=room)
def handleProcessedDataByDrone():
"""
Records processed and valid processed measurements every second by drone
qHAWAX: Record new measurement
"""
flag_email = False
data_json = request.get_json()
try:
product_id = data_json["ID"]
data_json = util_helper.validTimeJsonProcessed(data_json)
data_json = util_helper.validAndBeautyJsonProcessed(data_json)
post_data_helper.storeProcessedDataInDB(data_json)
data_json["ID"] = product_id
data_json = util_helper.setNoneStringElements(data_json)
for i in range(len(pollutants)):
socket_name = (data_json["ID"] + "_" + str(pollutants[i]) +
"_processed")
pollutant = (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"]
},
}
new_data_json[pollutants[i]] = data_json[pollutant]
socketio.emit(socket_name, new_data_json) # qH006_CO_proccessed
return make_response("OK", 200)
except TypeError as e:
json_message = jsonify({"error": "'%s'" % (e)})
return make_response(json_message, 400)
def recordEndTrip(qhawax_name, details):
qhawax_id = same_helper.getQhawaxID(qhawax_name)
name = qhawax_name.strip()
if qhawax_id != None:
finish_date = (
session.query(TripLog.trip_end)
.filter(TripLog.qhawax_id == qhawax_id)
.order_by(TripLog.id.desc())
.first()
)
if finish_date[0] == None:
installation_id = same_helper.getInstallationIdBaseName(
qhawax_name
)
if installation_id is not None:
value = (
session.query(ValidProcessedMeasurement.timestamp_zone)
.filter_by(qhawax_installation_id=installation_id)
.order_by(ValidProcessedMeasurement.id.desc())
.first()
.timestamp_zone
)
socketio.emit(name + "_finishTrip", str(value))
finish_json = {"trip_end": value, "details": details}
session.query(TripLog).filter_by(
qhawax_id=qhawax_id, trip_end=None
).update(values=finish_json)
session.commit()
def bm_send():
global client_bm
data_send = BabyMonitorService(BabyMonitorSend).last_record()
data_receive = BabyMonitorService(BabyMonitorReceive).last_record()
if not data_send:
data = generate_data("new")
elif data_send["type"] == "notification" and not data_receive:
data = generate_data("repeat")
elif (data_send["type"] == "notification"
and data_receive["id_notification"] != data_send["id"]):
data = generate_data("repeat")
elif (data_send["type"] == "notification"
and data_receive["id_notification"] == data_send["id"]):
data = generate_data("fine")
else:
data = generate_data("new")
data["type"] = ("notification" if data["crying"]
or data["time_no_breathing"] > 5 else "status")
BabyMonitorService(BabyMonitorSend).insert_data(data)
data["from"] = "bm"
data["to"] = "smp"
client_bm.publish_to_dojot(data)
print(f"send {data}")
socketio.emit("BabyMonitorSent", data)
return jsonify(data), 200
def handleProcessedDataByDrone():
"""
Records processed and valid processed measurements every second by drone
qHAWAX: Record new measurement
"""
flag_email = False
data_json = request.get_json()
try:
product_id = data_json['ID']
data_json = util_helper.validTimeJsonProcessed(data_json)
data_json = util_helper.validAndBeautyJsonProcessed(data_json)
post_data_helper.storeProcessedDataInDB(data_json)
data_json['ID'] = product_id
data_json = util_helper.setNoneStringElements(data_json)
for i in range(len(pollutants)):
socket_name = data_json['ID'] + '_' + str(
pollutants[i]) + '_processed'
pollutant = 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"]
}
}
new_data_json[pollutants[i]] = data_json[pollutant]
socketio.emit(socket_name, new_data_json) #qH006_CO_proccessed
return make_response('OK', 200)
except TypeError as e:
json_message = jsonify({'error': '\'%s\'' % (e)})
return make_response(json_message, 400)
def get_confirmation():
print(request.json)
print(f"receive {request.json}")
socketio.emit("BabyMonitorReceive", request.json)
last_data = BabyMonitorService(BabyMonitorSend).last_record()
confirmation = {"id_notification": last_data["id"]}
BabyMonitorService(BabyMonitorReceive).insert_data(confirmation)
return "OK"
def publish_info_baby(self, status):
global once
self.channel.basic_publish(
exchange=exchange,
routing_key=bm_info,
properties=pika.BasicProperties(delivery_mode=2, ),
body=json.dumps(status),
)
socketio.emit("BabyMonitorSent", status)
print("(Publish) BM: ", status)
def handleGasInca():
""" POST: Records gas and dust measurement in gas inca table """
try:
data_json = request.get_json()
post_data_helper.storeGasIncaInDB(data_json)
socketio.emit('gas_inca_summary', data_json)
return make_response('OK', 200)
except Exception as e:
json_message = jsonify({'error': '\'%s\'' % (e)})
return make_response(json_message, 400)
def wait_user_confirm(*body):
global confirm_user
for _ in range(5):
sleep(1)
if confirm_user:
return None
if not confirm_user:
forward_message_smart_tv(body)
socketio.emit("SmartphoneSent",
{"info": "Notification Forward to TV!"})
def forward_message(self):
last_record = BabyMonitorService(BabyMonitorSend).last_record()
notification = self.format_notification(last_record)
self.channel.basic_publish(
exchange=exchange,
routing_key=st_msg,
properties=pika.BasicProperties(delivery_mode=2, ),
body=json.dumps(notification),
)
socketio.emit("SmartphoneSent", notification)
print("(Publish) SM|ST: ", notification)
def recordStartTrip(qhawax_name):
qhawax_id = same_helper.getQhawaxID(qhawax_name)
name = qhawax_name.strip()
if qhawax_id != None:
start_trip = datetime.datetime.now(dateutil.tz.tzutc())
start = TripLog(
trip_start=datetime.datetime.now(dateutil.tz.tzutc()),
qhawax_id=qhawax_id,
)
session.add(start)
session.commit()
socketio.emit(name + "_startTrip", str(start_trip))
def callback(self, ch, method, properties, body):
ch.basic_ack(delivery_tag=method.delivery_tag)
body = body.decode("UTF-8")
body = json.loads(body)
socketio.emit("TvReceive", body)
last_record = SmartTvService().last_record()
if last_record is not None:
if not last_record['block']:
socketio.emit("FromSmartphone", body)
SmartTvPublisher().start()
def run(self):
last = SmartTvService().last_record()
if last:
last = last["block"]
message = {"type": "status", "block": last}
self.channel.basic_publish(
exchange=exchange,
routing_key=st_info,
properties=pika.BasicProperties(delivery_mode=2, ),
body=json.dumps(message),
)
socketio.emit("TvSent", {"type": "status", "block": last})
print("(Publish) ST: ", message)
def callback(self, ch, method, properties, body):
ch.basic_ack(delivery_tag=method.delivery_tag)
body = body.decode("UTF-8")
body = json.loads(body)
socketio.emit("TvReceive", body)
last_record = SmartTvService().last_record()
if last_record is not None:
# se não: Info -> "Notification: bla bla"
# both: pub st_info -> 'I'm tananam'
if not last_record['block']:
socketio.emit("TvInformation", body)
SmartTvPublisher().start()
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 babymonitor_connect():
global bm_on
bm_on = True
info = {"info": "Baby Monitor Start"}
socketio.emit("BabyMonitorInformation", info)
subscriber = BabyMonitorSubscriber()
subscriber.start()
while True:
sleep(1)
if bm_on:
publisher = BabyMonitorPublisher()
publisher.start()
else:
subscriber.stop()
break
def handleProcessedDataByQhawax():
"""
Records processed and valid processed measurements every five seconds
qHAWAX: Record new measurement
"""
flag_email = False
data_json = request.get_json()
try:
product_id = data_json["ID"]
data_json = util_helper.validTimeJsonProcessed(data_json)
data_json = util_helper.validAndBeautyJsonProcessed(data_json)
post_data_helper.storeProcessedDataInDB(data_json)
data_json["ID"] = product_id
data_json["zone"] = "Undefined Zone"
mode = same_helper.getQhawaxMode(product_id)
inca_value = same_helper.getMainIncaQhawaxTable(product_id)
# same endpoint for every qHAWAX but logic different per type of qHAWAX
if mode == "Customer" and inca_value != None:
data_json["zone"] = get_business_helper.getNoiseData(product_id)
(
minutes_difference,
last_time_turn_on,
) = get_business_helper.getHoursDifference(product_id)
if minutes_difference != None:
if minutes_difference < 5:
post_data_helper.validTimeOfValidProcessed(
10,
"minute",
last_time_turn_on,
data_json,
product_id,
inca_value,
)
elif minutes_difference >= 5:
post_data_helper.validTimeOfValidProcessed(
2,
"hour",
last_time_turn_on,
data_json,
product_id,
inca_value,
)
data_json = util_helper.setNoneStringElements(data_json)
socketio.emit(data_json["ID"] + "_processed", data_json)
return make_response("OK", 200)
except TypeError as e:
json_message = jsonify({"error": "'%s'" % (e)})
return make_response(json_message, 400)
def recordDroneTakeoff():
req_json = request.get_json()
try:
flight_start, qhawax_name = exception_helper.getJsonOfTakeOff(req_json)
if (get_business_helper.isAerealQhawax(qhawax_name) == True):
post_data_helper.recordDroneTakeoff(flight_start, qhawax_name)
socketio.emit(qhawax_name + '_takeoff', flight_start)
return make_response(
{'Success': 'The drone takeoff has been recorded'}, 200)
return make_response({'Warning': 'This is not an andean drone'}, 400)
except (TypeError, ValueError) as e:
json_message = jsonify({'error': '\'%s\'' % (e)})
return make_response(json_message, 400)
except (Exception) as e:
json_message = jsonify({'database error': '\'%s\'' % (e)})
return make_response(json_message, 400)
def recordDroneTakeoff():
req_json = request.get_json()
try:
flight_start, qhawax_name = exception_helper.getJsonOfTakeOff(req_json)
if get_business_helper.isAerealQhawax(qhawax_name) == True:
post_data_helper.recordDroneTakeoff(flight_start, qhawax_name)
socketio.emit(qhawax_name + "_takeoff", flight_start)
return make_response(
{"Success": "The drone takeoff has been recorded"}, 200)
return make_response({"Warning": "This is not an andean drone"}, 400)
except (TypeError, ValueError) as e:
json_message = jsonify({"error": "'%s'" % (e)})
return make_response(json_message, 400)
except (Exception) as e:
json_message = jsonify({"database error": "'%s'" % (e)})
return make_response(json_message, 400)
def storeValidProcessedDataInDB(data, product_id):
""" Helper Processed Measurement function to insert Valid Processed Data """
installation_id = same_helper.getInstallationIdBaseName(product_id)
if(installation_id!=None):
valid_data = {'timestamp': data['timestamp'],'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': data['O3'],'O3_ug_m3': data['O3_ug_m3'],'PM25': data['PM25'],
'lat':data['lat'],'lon':data['lon'],'PM1': data['PM1'],'PM10': data['PM10'], 'UV': data['UV'],
'UVA': data['UVA'],'UVB': data['UVB'],'SPL': data['spl'],'humidity': data['humidity'], 'CO2':data['CO2'],
'pressure': data['pressure'],'temperature': data['temperature'],'timestamp_zone': data['timestamp_zone'],
'I_temperature':data['I_temperature'],'VOC':data['VOC']}
valid_processed_measurement = ValidProcessedMeasurement(**valid_data, qhawax_installation_id=installation_id)
session.add(valid_processed_measurement)
session.commit()
data = util_helper.setNoneStringElements(data)
socketio.emit(data['ID'], data)
def user_select():
import project.routes.sockets as socket_global
try:
response = request.json
room = response['room']
user = response['user']
gif = response['gif']
socket_global.ROOMS[room]['gifPicks'][user] = gif
socketio.emit('status', {'msg': socket_global.ROOMS[room]}, room=room)
return jsonify({'error': '', 'selectedGif': gif})
except Exception as msg:
print(msg)
return jsonify({'error': 'cannot post', 'selectedGif': ''})
def updateIncaData():
""" Server Open Source / Server Comercial - To save qHAWAX inca value """
jsonsend = {}
req_json = request.get_json()
try:
name, value_inca = exception_helper.getIncaTargetofJson(req_json)
post_business_helper.updateMainIncaQhawaxTable(value_inca, name)
post_business_helper.updateMainIncaQhawaxInstallationTable(
value_inca, name)
jsonsend['main_inca'] = value_inca
jsonsend['name'] = name
socketio.emit('update_inca', jsonsend)
return make_response({'Success': ' save inca value'}, 200)
except (ValueError, TypeError) as e:
json_message = jsonify({'error': '\'%s\'' % (e)})
return make_response(json_message, 400)
def babymonitor_connect():
global bm_on
bm_on = True
data = data_from_baby("fine")
data['type'] = 'status'
BabyMonitorService(BabyMonitorSend).insert_data(data)
info = {"info": "Baby Monitor Start"}
socketio.emit("BabyMonitorInformation", info)
subscriber = BabyMonitorSubscriber()
subscriber.start()
while True:
sleep(1)
if bm_on:
publisher = BabyMonitorPublisher()
publisher.start()
else:
subscriber.stop()
break
def smartphone_connect():
global sp_on
sp_on = True
info = {"info": "Smartphone Start"}
socketio.emit("SmartphoneInformation", info)
# check_user_confirm = checkUserConfirm()
subscriber_bm = SmartphoneSubscriber("babymonitor")
subscriber_tv = SmartphoneSubscriber("smart_tv")
subscriber_bm.start()
subscriber_tv.start()
# check_user_confirm.start()
while True:
sleep(1)
if not sp_on:
subscriber_bm.stop()
subscriber_tv.stop()
# check_user_confirm.stop()
break
def block_tv(blocked):
if blocked:
info = {"info": "Tv blocked"}
socketio.emit("TvInformation", info)
socketio.emit("RedColor")
SmartTvService().insert_data(dict(block=True))
else:
info = {"info": "Tv available"}
socketio.emit("TvInformation", info)
socketio.emit("NormalColor")
SmartTvService().insert_data(dict(block=False))
def recordDroneLanding():
req_json = request.get_json()
try:
flight_end, qhawax_name, flight_detail, location = exception_helper.getJsonOfLanding(
req_json)
if (get_business_helper.isAerealQhawax(qhawax_name) == True):
post_data_helper.recordDroneLanding(flight_end, qhawax_name,
flight_detail)
post_business_helper.updateLastLocation(qhawax_name, location)
socketio.emit(qhawax_name + '_landing', flight_end)
return make_response(
{'Success': 'The drone landing has been recorded'}, 200)
return make_response({'Warning': 'This is not an andean drone'}, 400)
except (TypeError, ValueError) as e:
json_message = jsonify({'error': '\'%s\'' % (e)})
return make_response(json_message, 400)
except (Exception) as e:
json_message = jsonify({'database error': '\'%s\'' % (e)})
return make_response(json_message, 400)
def handleTelemetry():
global drone_telemetry
try:
data_json = request.get_json()
token = (data_json["token"] if
(data_json["token"] == "droneandino123") else None)
room = data_json["room"] # El room es el qhawax ID
telemetry = data_json["telemetry"]
except KeyError as e:
json_message = jsonify({"error": "'%s'" % (e)})
return make_response(json_message, 400)
if get_business_helper.isAerealQhawax(room) == True:
telemetry["ID"] = room
socketio.emit(room + "_telemetry", telemetry)
drone_telemetry = telemetry
post_data_helper.storeLogs(telemetry, room)
return make_response(
{"success": "Telemetry sent from drone: " + str(room)}, 200)
return make_response(
{"warning": "qHAWAX " + str(room) + " is not aereal "}, 400)
def publish_info_baby(self, status):
global once
'''if status["type"] == "notification" and once:
random.seed(datetime.now())
choice = random.choices([True, False], [0.0, 1.0], k=1)[0]
if choice:
user_confirm()
once = False
if status["type"] == "status":
once = True'''
self.channel.basic_publish(
exchange=exchange,
routing_key=bm_info,
properties=pika.BasicProperties(delivery_mode=2,),
body=json.dumps(status),
)
socketio.emit("BabyMonitorSent", status)
print("(Publish) BM: ", status)
