def create_badge(self, name, email, mac): """ Creates a badge using the giving information :param name: user name :param email: user email :param mac: badge mac :return: """ try: data = { 'name': name, 'email': email, 'badge': mac, } self.logger.info("Creating new badge : {}".format(data)) response = requests.post(BADGES_ENDPOINT, data=data, headers=request_headers()) if response.ok is False: s = traceback.format_exc() raise Exception( 'Error creating badge {}. Status: {}, Error: {}, {}'. format(data, response.status_code, response.text, s)) except Exception as e: s = traceback.format_exc() self.logger.error('Error creating new badge. Error: {} ,{}'.format( e, s))
def create_beacon(self, name, mac, beacon_id, project_id): """ Creates a beacon using the giving information :param name: user name :param mac: beacon mac :param beacon_id: beacon_id :param project_id: project_id :return: """ try: data = { 'name': name, 'badge': mac, 'id': beacon_id, 'project_id': project_id, } self.logger.info("Creating new beacon : {}".format(data)) response = requests.post(BEACONS_ENDPOINT, data=data, headers=request_headers(), timeout=self.DEFAULT_TIMEOUT) if response.ok is False: s = traceback.format_exc() raise Exception( 'Error creating beacon {}. Status: {}, Error: {}, {}'. format(data, response.status_code, response.text, s)) except Exception as e: s = traceback.format_exc() self.logger.error( 'Error creating new beacon. Error: {} ,{}'.format(e, s))
def send_badge(self, mac): """ Sends timestamps of the given badge to the server :param mac: :return: """ try: badge = self._badges[mac] data = { 'last_audio_ts': badge.last_audio_ts_int, 'last_audio_ts_fract': badge.last_audio_ts_fract, 'last_proximity_ts': badge.last_proximity_ts, 'last_voltage': badge.last_voltage, 'last_seen_ts': badge.last_seen_ts, } self.logger.debug( "Sending update badge data to server, badge {} : {}".format( badge.key, data)) response = requests.patch(BADGE_ENDPOINT(badge.key), data=data, headers=request_headers()) if response.ok is False: if response.status_code == 400: self.logger.debug( "Server had more recent date, badge {} : {}".format( badge.key, response.text)) else: raise Exception( 'Server sent a {} status code instead of 200: {}'. format(response.status_code, response.text)) except Exception as e: self.logger.error( 'Error sending updated badge into to server: {}'.format(e))
def send_beacon(self, mac): """ Sends timestamps of the given beacon to the server :param mac: :return: """ try: beacon = self._beacons[mac] data = { 'observed_id': beacon.observed_id, 'last_voltage': beacon.last_voltage, 'last_seen_ts': beacon.last_seen_ts, } self.logger.debug( "Sending update beacon data to server, beacon {} : {}".format( beacon.key, data)) response = requests.patch(BEACON_ENDPOINT(beacon.key), data=data, headers=request_headers(), timeout=self.DEFAULT_TIMEOUT) if response.ok is False: if response.status_code == 400: self.logger.debug( "Server had more recent date, beacon {} : {}".format( beacon.key, response.text)) else: raise Exception( 'Server sent a {} status code instead of 200: {}'. format(response.status_code, response.text)) except Exception as e: self.logger.error( 'Error sending updated beacon info to server: {}'.format(e))
def _get_project_id(logger): resp = requests.request("GET", PROJECTS_ENDPOINT, headers=request_headers()) if resp.status_code == 200: return resp.json()["key"] else: #TODO what do #I don't think this is likely to ever happen, at least logger.error( "Error getting project key from server, status code: {}".format( resp.status_code))
def _read_badges_list_from_server(self, retry=True, retry_delay_sec=5): """ Reads badges info from the server :param retry: if blocking is set, hub will keep retrying :return: """ server_badges = {} done = False while not done: try: self.logger.info("Requesting devices from server...") response = requests.get(BADGES_ENDPOINT, headers=request_headers(), timeout=self.DEFAULT_TIMEOUT) if response.ok: self.logger.info("Updating devices list ({})...".format( len(response.json()))) for d in response.json(): if (d.get('active') == True): server_badges[d.get( 'badge')] = self._jason_badge_to_object(d) done = True else: raise Exception('Got a {} from the server'.format( response.status_code)) except (requests.exceptions.ConnectionError, Exception) as e: s = traceback.format_exc() self.logger.error( "Error reading badges list from server : {}, {}".format( e, s)) if not retry: done = True else: self.logger.info( "Sleeping for {} seconds before retrying".format( retry_delay_sec)) time.sleep(retry_delay_sec) return server_badges
def send_data_to_server(logger, data_type, data): """ Send data to the server Args: logger: for logging events/errors data_type: audio or proximity data: a json array containing the data to send Returns: the number of chunks written on the server Raises: RequestException: raises if the status code indicates an http error """ project_id = _get_project_id(logger) headers = request_headers() headers["content-type"] = "application/json" payload = {"data_type": data_type, "chunks": data} url = DATA_ENDPOINT(project_id) response = requests.request("POST", url, data=json.dumps(payload), headers=headers) response.raise_for_status() return response.json()["chunks_written"]
def _read_beacon_from_server(self, beacon_key, retry=False, retry_delay_sec=5): """ Reads given beacon info from the server :param retry: if blocking is set, hub will keep retrying :return: """ done = False while not done: try: self.logger.info( "Requesting device {} from server...".format(beacon_key)) response = requests.get(BEACON_ENDPOINT(beacon_key), headers=request_headers(), timeout=self.DEFAULT_TIMEOUT) if response.ok: #self.logger.debug("Received ({})...".format(response.json())) return self._jason_beacon_to_object(response.json()) else: raise Exception('Got a {} from the server'.format( response.status_code)) except (requests.exceptions.ConnectionError, Exception) as e: self.logger.error( "Error reading badge from server : {}".format(e)) if not retry: done = True else: self.logger.info( "Sleeping for {} seconds before retrying".format( retry_delay_sec)) time.sleep(retry_delay_sec) return None