class ActivationService:
def __init__(self):
configuration = ConfigurationStore().get()
self.device_id = configuration.get_device_id()
self.bot_service = BoTService()
def run(self):
Logger.info(LOCATION, 'Starting to activate device...')
for tries in range(1, MAXIMUM_TRIES + 1):
Logger.info(LOCATION, 'Activating device, attempt: ' + str(tries))
if self.activate():
return True
time.sleep(POLLING_INTERVAL_IN_SECONDS)
return False
def activate(self):
try:
self.bot_service.post(RESOURCE, {DEVICE_ID: self.device_id})
Logger.success(
LOCATION,
'Device successfully activated. Triggering actions enabled.')
return True
# TODO : Make exception more specific
except:
Logger.error(LOCATION, 'Failed to activate device.')
return False
class PairingService:
def __init__(self):
configuration = ConfigurationStore().get()
self.maker_id = configuration.get_maker_id()
self.device_id = configuration.get_device_id()
self.bot_service = BoTService()
def run(self):
Logger.info(LOCATION, 'Starting to pair device...')
for tries in range(1, MAXIMUM_TRIES + 1):
Logger.info(LOCATION, 'Pairing device, attempt: ' + str(tries))
if self.pair():
return True
time.sleep(POLLING_INTERVAL_IN_SECONDS)
return False
def pair(self):
try:
response = self.bot_service.get(RESOURCE)
except:
Logger.error(LOCATION, 'Failed pairing attempt.')
return False
if response['status'] is True:
Logger.success(LOCATION, 'Device successfully paired.')
return True
else:
Logger.error(LOCATION, 'Failed pairing attempt.')
return False
class PairingService:
def __init__(self):
configuration = ConfigurationStore().get()
self.maker_id = configuration.get_maker_id()
self.device_id = configuration.get_device_id()
self.device_status = configuration.get_device_status()
self.bot_service = BoTService()
def run(self):
# Multipairing device and new device can pair device.
if not self.isPairable:
return
if (self.device_status == DeviceStatus.MULTIPAIR):
Logger.info(LOCATION,
'Multipair mode, no need to poll or delete keys...')
return
Logger.info(LOCATION, 'Starting to pair device...')
for tries in range(1, MAXIMUM_TRIES + 1):
Logger.info(LOCATION, 'Pairing device, attempt: ' + str(tries))
if self.pair():
return True
time.sleep(POLLING_INTERVAL_IN_SECONDS)
return False
# Checking the device status for pairable.
# Only Multi pairing and new device can pair with the mobile.
def isPairable(self):
if (self.device_status == DeviceStatus.MULTIPAIR):
return True
return self.device_status == DeviceStatus.NEW
def pair(self):
try:
response = self.bot_service.get(RESOURCE)
except:
Logger.error(LOCATION, 'Failed pairing attempt.')
return False
if response['status'] is True:
Logger.success(LOCATION, 'Device successfully paired.')
return True
else:
Logger.error(LOCATION, 'Failed pairing attempt.')
return False
class PairingService:
def __init__(self):
configuration = ConfigurationStore().get()
self.maker_id = configuration.get_maker_id()
self.device_id = configuration.get_device_id()
self.device_status = configuration.get_device_status()
self.bot_service = BoTService()
def run(self):
if not self.can_pair:
return
if self.device_status == DeviceStatus.MULTIPAIR:
Logger.info(LOCATION,
'Multipair mode, no need to poll or delete keys...')
return
Logger.info(LOCATION, 'Starting to pair device...')
for tries in range(1, MAXIMUM_TRIES + 1):
Logger.info(LOCATION, 'Pairing device, attempt: ' + str(tries))
if self.pair():
return True
time.sleep(POLLING_INTERVAL_IN_SECONDS)
return False
def can_pair(self):
return self.device_status == DeviceStatus.MULTIPAIR or self.device_status == DeviceStatus.NEW
def pair(self):
try:
response = self.bot_service.get(RESOURCE)
Logger.info(LOCATION, 'Pairing Response: ' + str(response))
# TODO : Make exception more specific
except:
Logger.error(LOCATION, 'Failed pairing attempt.')
return False
if response['status'] is True:
Logger.success(LOCATION, 'Device successfully paired.')
return True
else:
Logger.error(LOCATION, 'Failed pairing attempt.')
return False
def __init__(self):
configuration = ConfigurationStore().get()
self.maker_id = configuration.get_maker_id()
self.device_id = configuration.get_device_id()
self.device_status = configuration.get_device_status()
self.bot_service = BoTService()
def __init__(self):
self.configuration = ConfigurationStore().get()
self.bot_service = BoTService()
self.key_generator = KeyGenerator()
self.store = Store()
class ActionService:
def __init__(self):
self.configuration = ConfigurationStore().get()
self.bot_service = BoTService()
self.key_generator = KeyGenerator()
self.store = Store()
def get_actions(self):
Logger.info(LOCATION, 'Retrieving actions...')
try:
actions = self.bot_service.get(ACTIONS_ENDPOINT)
Logger.success(
LOCATION, 'Successfully retrieved ' + str(len(actions)) +
' action(s) from server')
Store.set_actions(actions)
return actions
except falcon.HTTPServiceUnavailable:
Logger.warning(
LOCATION,
'Unable to retrieve actions from server. Loading locally stored action(s)...'
)
actions = self.store.get_actions()
Logger.success(
LOCATION, 'Successfully loaded ' + str(len(actions)) +
' cached action(s)')
return actions
def trigger(self, action_id, value=None, alternative_id=None):
Logger.info(LOCATION, 'Triggering action: ' + action_id)
action = self._get_action(action_id)
self._validate_frequency(action)
Logger.success(LOCATION, 'Action valid')
data = self._create_trigger_body(action_id, value, alternative_id)
try:
self.bot_service.post(ACTIONS_ENDPOINT, data)
Logger.success(LOCATION,
'Successfully triggered action: ' + action_id)
self.store.set_last_triggered(action_id, time.time())
return True
# TODO : Make exception more specific
except:
Logger.error(LOCATION, 'Unable to trigger action: ' + action_id)
return False
def _validate_frequency(self, action):
last_triggered = self.store.get_last_triggered(action[ACTION_ID])
if last_triggered is None:
return # It was never triggered, so it is valid, unless we ever introduce Frequency: 'never'
frequency = action[FREQUENCY]
if frequency not in FrequenciesInSeconds.keys():
self._handle_unsupported_frequency(frequency)
if FrequenciesInSeconds[frequency] > time.time() - last_triggered:
self._handle_maximum_frequency(frequency)
def _get_action(self, action_id):
actions = self.get_actions()
for action in actions:
if action[ACTION_ID] == action_id:
Logger.success(LOCATION, 'Action found')
return action
Logger.error(LOCATION, 'Action not found')
raise falcon.HTTPNotFound(description='Action not found')
def _create_trigger_body(self, action_id, value, alternative_id):
data = {
ACTION_ID: action_id,
DEVICE_ID: self.configuration.get_device_id(),
QUEUE_ID: self.key_generator.generate_uuid()
}
if alternative_id is not None:
data[ALTERNATIVE_ID] = str(alternative_id)
if value is not None:
data[VALUE] = str(value)
return data
@staticmethod
def _handle_unsupported_frequency(frequency):
error = 'Frequency not supported: ' + frequency
Logger.error(LOCATION, error)
raise falcon.HTTPBadRequest(description=error)
@staticmethod
def _handle_maximum_frequency(frequency):
error = 'Maximum ' + frequency + ' triggers reached'
Logger.error(LOCATION, error)
raise falcon.HTTPBadRequest(description=error)