def glasses_request() -> Response: """ This function can register new glasses in the OGC server. :return: An HTTP Response. """ logging.debug(glasses_request.__name__ + " method called from: " + request.remote_addr) ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status glasses_id = request.json[TAG_ID_KEY] if request.method == "POST": # POST # -> ### DATASTREAM REGISTRATION ### rc = scral_module.get_resource_catalog() if glasses_id in rc: logging.error("Device already registered!") return make_response( jsonify({ERROR_RETURN_STRING: DUPLICATE_REQUEST}), 422) logging.info("Glasses: '" + str(glasses_id) + "' registration.") ok = scral_module.ogc_datastream_registration(glasses_id) if not ok: return make_response( jsonify({ERROR_RETURN_STRING: INTERNAL_SERVER_ERROR}), 500) else: return make_response(jsonify({SUCCESS_RETURN_STRING: "Ok"}), 201) elif request.method == "DELETE": # DELETE response = scral_module.delete_device(glasses_id) return response
def wristband_request() -> Response: logging.debug(wristband_request.__name__ + " method called from: " + request.remote_addr) ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status wristband_id = request.json[TAG_ID_KEY] if request.method == "POST": # Device Registration rc = scral_module.get_resource_catalog() if wristband_id not in rc: logging.info("Wristband: '" + str(wristband_id) + "' registration.") else: logging.warning( "Device '" + str(wristband_id) + "' already registered... It will be overwritten on RC!") ok = scral_module.ogc_datastream_registration(wristband_id, request.json) if not ok: return make_response( jsonify({ERROR_RETURN_STRING: INTERNAL_SERVER_ERROR}), 500) else: return make_response(jsonify({SUCCESS_RETURN_STRING: "Ok"}), 201) elif request.method == "DELETE": # Remove Device response = scral_module.delete_device(wristband_id) return response
def put_observation(observed_property: str, payload: dict) -> Response: """ This function is used to store a new OBSERVATION in the OGC Server. :param observed_property: The type of property :param payload: The payload of the observation :return: An HTTP request. """ ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status glasses_id = payload[TAG_ID_KEY] result = scral_module.ogc_observation_registration(observed_property, payload) if result is True: return make_response(jsonify({SUCCESS_RETURN_STRING: "Ok"}), 201) elif result is None: logging.error("Glasses: '" + str(glasses_id) + "' was not registered.") return make_response( jsonify({ERROR_RETURN_STRING: DEVICE_NOT_REGISTERED}), 400) else: logging.error("Impossible to publish on MQTT server.") return make_response( jsonify({ERROR_RETURN_STRING: INTERNAL_SERVER_ERROR}), 500)
def new_device_localization() -> Response: """ This function is used to store a new OBSERVATION in the OGC Server. :return: An HTTP request. """ logging.debug(new_device_localization.__name__ + " method called from: " + request.remote_addr) ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status payload = request.json device_id = payload[DEVICE_ID_KEY] # you should use the same property_name used in the ogc_config.conf file result = scral_module.ogc_observation_registration("Property1", payload) if result is True: return make_response(jsonify({SUCCESS_RETURN_STRING: "Ok"}), 201) elif result is None: logging.error("Device: '" + str(device_id) + "' was not registered.") return make_response( jsonify({ERROR_RETURN_STRING: DEVICE_NOT_REGISTERED}), 400) else: logging.error("Impossible to publish on MQTT server.") return make_response( jsonify({ERROR_RETURN_STRING: INTERNAL_SERVER_ERROR}), 500)
def remove_gps_tag() -> Response: """ This function delete all the DATASTREAM associated with a particular device on the resource catalog and on the OGC server. :return: An HTTP Response. """ logging.debug(remove_gps_tag.__name__ + ", " + request.method + " method called from: " + request.remote_addr) ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status else: response = scral_module.delete_device(request.json[TAG_ID_KEY]) return response
def delete_device() -> Response: """ This function can be used to register a new device in the OGC server. :return: An HTTP Response. """ logging.debug(delete_device.__name__ + " method called from: " + request.remote_addr) ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status device_id = request.json[DEVICE_ID_KEY] response = scral_module.delete_device(device_id) return response
def new_sound_event() -> Response: """ This function can register an OBSERVATION in the OGC server. It is able to accept any new OBSERVED PROPERTY according to the content of "type" field. This new property is run-time generated. :return: An HTTP Response. """ logging.debug(new_sound_event.__name__ + " method called from: " + request.remote_addr) ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status payload = request.json lower_payload = {k.lower(): v for k, v in request.json.items() } # this payload has all the keys in lower case property_name = lower_payload[TYPE_KEY.lower( )] # accessing to lower_payload fields require to lower constants too try: property_description = lower_payload[DESCRIPTION_KEY.lower()] except KeyError: property_description = property_name + " description" try: property_definition = lower_payload[DEFINITION_KEY.lower()] except KeyError: property_definition = property_name + " definition" obs_prop = OGCObservedProperty(property_name, property_description, property_definition) device_id = lower_payload[DEVICE_ID_KEY.lower()] datastream_id = scral_module.new_datastream(device_id, obs_prop) if datastream_id is False: return make_response( jsonify({ERROR_RETURN_STRING: DEVICE_NOT_REGISTERED}), 400) elif datastream_id is None: return make_response( jsonify({ERROR_RETURN_STRING: INTERNAL_SERVER_ERROR}), 500) else: scral_module.ogc_observation_registration( datastream_id, lower_payload[START_TIME_KEY.lower()], payload) return make_response(jsonify({SUCCESS_RETURN_STRING: "Ok"}), 201)
def register_device() -> Response: """ This function can be used to register a new device in the OGC server. :return: An HTTP Response. """ logging.debug(register_device.__name__ + " method called from: " + request.remote_addr) ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status device_id = request.json[DEVICE_ID_KEY] logging.info("Device: '" + str(device_id) + "' registration.") ok = scral_module.ogc_datastream_registration(device_id) if not ok: return make_response( jsonify({ERROR_RETURN_STRING: INTERNAL_SERVER_ERROR}), 500) else: return make_response(jsonify({SUCCESS_RETURN_STRING: "Ok"}), 201)
def new_gps_tag_request() -> Response: logging.debug(new_gps_tag_request.__name__ + " method called from: "+request.remote_addr) ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status gps_tag_id = request.json[TAG_ID_KEY] # -> ### DATASTREAM REGISTRATION ### rc = scral_module.get_resource_catalog() if gps_tag_id not in rc: logging.info("GPS tag: '" + str(gps_tag_id) + "' registration.") ok = scral_module.new_datastream(request.json) if not ok: return make_response(jsonify({ERROR_RETURN_STRING: INTERNAL_SERVER_ERROR}), 500) return make_response(jsonify({SUCCESS_RETURN_STRING: "Ok"}), 201) else: logging.error("Device already registered!") return make_response(jsonify({ERROR_RETURN_STRING: DUPLICATE_REQUEST}), 422)
def new_wristband_association_request() -> Response: logging.debug(new_wristband_association_request.__name__ + " method called from: " + request.remote_addr) ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status wristband_id_1 = request.json[ID1_ASSOCIATION_KEY] wristband_id_2 = request.json[ID2_ASSOCIATION_KEY] rc = scral_module.get_resource_catalog() if wristband_id_1 not in rc or wristband_id_2 not in rc: logging.error("One of the wristbands is not registered.") return make_response( jsonify({ ERROR_RETURN_STRING: "One of the wristbands is not registered!" }), 400) vds = scral_module.get_ogc_config().get_virtual_datastream( SENSOR_ASSOCIATION_NAME) if not vds: logging.critical( 'No Virtual DATASTREAM registered for Virtual SENSOR: "' + SENSOR_ASSOCIATION_NAME + '"') return make_response( jsonify({ERROR_RETURN_STRING: INTERNAL_SERVER_ERROR}), 500) result = scral_module.ogc_service_observation_registration( vds, request.json) if result is True: return make_response(jsonify({SUCCESS_RETURN_STRING: "Ok"}), 201) else: logging.error("Impossible to publish on MQTT server.") return make_response( jsonify({ERROR_RETURN_STRING: NO_MQTT_PUBLICATION}), 502)
def camera_request() -> Response: """ This function can register new camera in the OGC server or store new OGC OBSERVATIONs. :return: An HTTP Response. """ logging.debug(camera_request.__name__ + ", " + request.method + " method called from: " + request.remote_addr) ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status if request.method == "POST": # POST camera_id = request.json[CAMERA_ID_KEY] rc = scral_module.get_resource_catalog() if camera_id not in rc: logging.info('Camera: "' + str(camera_id) + '" registration.') response = scral_module.ogc_datastream_registration( camera_id, CAMERA_SENSOR_TYPE, request.json) else: logging.error("Camera already registered!") response = make_response( jsonify({ERROR_RETURN_STRING: DUPLICATE_REQUEST}), 422) return response elif request.method == "PUT": # PUT camera_id = str(request.json[CAMERA_IDS_KEY][0]) logging.info("New OBSERVATION from camera: '" + str(camera_id) + "'.") property_type = request.json[TYPE_MODULE_KEY] if property_type == FIGHT_KEY: observed_property = "FD-Estimation" elif property_type == CROWD_KEY: observed_property = "CDL-Estimation" elif property_type == FLOW_KEY: observed_property = "FA-Estimation" elif property_type == OBJECT_KEY: observed_property = "OD-Estimation" elif property_type == GATE_COUNT_KEY: observed_property = "GC-Estimation" else: logging.error("Unknown property: <" + property_type + ">.") return make_response( jsonify({ ERROR_RETURN_STRING: "Unknown property <" + property_type + ">." }), 400) response = put_observation(camera_id, observed_property, request.json) return response elif request.method == "DELETE": try: camera_id = request.json[CAMERA_ID_KEY] logging.info('Try to delete camera: "' + camera_id + '"') response = scral_module.delete_device(camera_id) except KeyError: logging.error("Missing " + CAMERA_ID_KEY + ". Delete aborted.") response = make_response( jsonify({ERROR_RETURN_STRING: WRONG_PAYLOAD_REQUEST}), 400) return response else: logging.critical("Unauthorized method!") return make_response(jsonify({ERROR_RETURN_STRING: WRONG_REQUEST}), 405)
def cdg_request() -> Response: """ This function can register new Crowd Density Global in the OGC server or store new OGC OBSERVATIONs. :return: An HTTP Response. """ logging.debug(cdg_request.__name__ + ", " + request.method + " method called from: " + request.remote_addr) ok, status = rest_util.tests_and_checks(DOC[MODULE_NAME_KEY], scral_module, request) if not ok: return status cdg_module_id = None try: cdg_module_id = request.json[ MODULE_ID_KEY] # NB: module here is Crowd Density Global module except KeyError: logging.error("Missing " + MODULE_ID_KEY + ". Request aborted.") return make_response( jsonify({ERROR_RETURN_STRING: WRONG_PAYLOAD_REQUEST}), 400) if request.method == "POST": # POST rc = scral_module.get_resource_catalog() if cdg_module_id not in rc: logging.info("CDG: '" + str(cdg_module_id) + "' registration.") response = scral_module.ogc_datastream_registration( cdg_module_id, CDG_SENSOR_TYPE, request.json) else: logging.error("CDG module already registered!") response = make_response( jsonify({ERROR_RETURN_STRING: DUPLICATE_REQUEST}), 422) return response elif request.method == "PUT": # PUT logging.info("New OBSERVATION from CDG: '" + str(cdg_module_id)) property_type = request.json[TYPE_MODULE_KEY] request.json[TIMESTAMP_KEY] = request.json.pop( "timestamp_1") # renaming "timestamp_1" to "timestamp" if property_type == CDG_KEY: observed_property = CDG_PROPERTY else: logging.error("Unknown property.") return make_response( jsonify({ERROR_RETURN_STRING: UNKNOWN_PROPERTY}), 400) response = put_observation(cdg_module_id, observed_property, request.json) return response elif request.method == "DELETE": # DELETE logging.info('Try to delete CDG: "' + cdg_module_id + '"') response = scral_module.delete_device(cdg_module_id) return response else: logging.critical("Unauthorized method!") return make_response(jsonify({ERROR_RETURN_STRING: WRONG_REQUEST}), 405)