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)