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
