def validate_device_update(context):
"""Validate that the non-Pantacor device attributes are updated correctly."""
device_repo = DeviceRepository(context.db)
device = device_repo.get_device_by_id(context.device_id)
assert_that(device.core_version, equal_to("test_core_version"))
assert_that(device.platform, equal_to("test_platform"))
assert_that(device.enclosure_version, equal_to("test_enclosure_version"))
def _add_device(self, device: NewDeviceRequest):
"""Creates a device and associate it to a pairing session"""
device_dict = device.to_native()
geography_id = self._ensure_geography_exists(self.db, device_dict)
device_dict.update(geography_id=geography_id)
device_repository = DeviceRepository(self.db)
device_id = device_repository.add(self.account.id, device_dict)
return device_id
def _run(self):
device_repo = DeviceRepository(self.db)
devices_updated = 0
for device in device_repo.get_all_device_ids():
last_contact_ts = self._get_ts_from_cache(device.id)
if last_contact_ts is not None:
devices_updated += 1
device_repo.update_last_contact_ts(device.id, last_contact_ts)
self.log.info(str(devices_updated) + ' devices were active today')
def _update_device(self, device_id, updates):
device_updates = updates.to_native()
geography_id = self._ensure_geography_exists(self.db, device_updates)
device_updates.update(geography_id=geography_id)
device_repository = DeviceRepository(self.db)
device_repository.update_device_from_account(
self.account.id,
device_id,
device_updates
)
def _get_device(self, device_id: str) -> dict:
"""Get the device information for a specific device.
:param device_id: Identifier of the device to retrieve
:return: device information to return to the UI
"""
device_repository = DeviceRepository(self.db)
device = device_repository.get_device_by_id(device_id)
response_data = self._format_device_for_response(device)
return response_data
def validate_response(context):
device_id = context.response.data.decode()
account = context.accounts["foo"]
db = connect_to_db(context.client_config["DB_CONNECTION_CONFIG"])
device_repository = DeviceRepository(db)
device = device_repository.get_device_by_id(device_id)
assert_that(device, not_none())
assert_that(device.name, equal_to("Selene Test Device"))
assert_that(device.placement, equal_to("Mycroft Offices"))
assert_that(device.account_id, equal_to(account.id))
def _get_devices(self):
device_repository = DeviceRepository(self.db)
devices = device_repository.get_devices_by_account_id(
self.account.id
)
response_data = []
for device in devices:
response_device = self._format_device_for_response(device)
response_data.append(response_device)
return response_data
def _delete_device(self, device_id: str):
"""Delete the specified device from the database.
There are other tables related to the device table in the database. This
method assumes that the child tables contain "delete cascade" clauses.
:param device_id: database identifier of a device
"""
device_repository = DeviceRepository(self.db)
device_repository.remove(device_id)
delete_device_login(device_id, self.cache)
def validate_pantacor_update(context):
"""Validate that the Pantacor config of the device is stored in the database."""
device_repo = DeviceRepository(context.db)
device = device_repo.get_device_by_id(context.device_id)
assert_that(device.pantacor_config, not_none())
assert_that(device.pantacor_config.pantacor_id,
equal_to("test_pantacor_id"))
assert_that(device.pantacor_config.release_channel,
equal_to("test_channel_name"))
assert_that(device.pantacor_config.auto_update, equal_to(True))
assert_that(device.pantacor_config.ip_address, equal_to("192.168.1.2"))
assert_that(device.pantacor_config.ssh_public_key, none())
def _add_device(self, device: NewDeviceRequest) -> str:
"""Creates a device and associate it to a pairing session.
:param device: Schematic containing the request data
:return: the database identifier of the new device
"""
device_dict = device.to_native()
geography_id = self._ensure_geography_exists(device_dict)
device_dict.update(geography_id=geography_id)
device_repository = DeviceRepository(self.db)
device_id = device_repository.add(self.account.id, device_dict)
return device_id
def _get_devices(self) -> List[dict]:
"""Get a list of the devices belonging to the account in the request JWT
:return: list of devices to be returned to the UI.
"""
device_repository = DeviceRepository(self.db)
devices = device_repository.get_devices_by_account_id(self.account.id)
response_data = []
for device in devices:
response_device = self._format_device_for_response(device)
response_data.append(response_device)
return response_data
def _update_device(self, device_id: str, updates: UpdateDeviceRequest):
"""Update the device attributes on the database based on the request.
:param device_id: database identifier of a device
:param updates: The new values of the device attributes
:return:
"""
device_updates = updates.to_native()
geography_id = self._ensure_geography_exists(device_updates)
device_updates.update(geography_id=geography_id)
device_repository = DeviceRepository(self.db)
device_repository.update_device_from_account(self.account.id,
device_id, device_updates)
def validate_response(context):
"""Ensure that the database was updated as expected."""
account = context.accounts["foo"]
db = connect_to_db(context.client_config["DB_CONNECTION_CONFIG"])
device_repository = DeviceRepository(db)
devices = device_repository.get_devices_by_account_id(account.id)
device = None
for device in devices:
if device.name == "Selene Test Device":
break
assert_that(device, not_none())
assert_that(device.name, equal_to("Selene Test Device"))
assert_that(device.placement, equal_to("Mycroft Offices"))
assert_that(device.account_id, equal_to(account.id))
context.device_id = device.id
def add_device(db, account_id, geography_id):
device = dict(name='Selene Test Device',
pairing_code='ABC123',
placement='kitchen',
geography_id=geography_id,
country='United States',
region='Missouri',
city='Kansas City',
timezone='America/Chicago',
wake_word='Selene Test Wake Word',
voice='Selene Test Voice')
device_repository = DeviceRepository(db)
device_id = device_repository.add(account_id, device)
return device_id
def _activate(self, device_id: str, activation_request: ActivationRequest):
"""Updates the core version, platform and enclosure_version columns"""
updates = dict(platform=str(activation_request.platform),
enclosure_version=str(
activation_request.enclosureVersion),
core_version=str(activation_request.coreVersion))
DeviceRepository(self.db).update_device_from_core(device_id, updates)
def expire_device_location_etag_by_account_id(self, account_id: str):
"""Expire the locations' etag fpr açç device for a given acccount
:param account_id: account uuid"""
db = connect_to_db(self.db_connection_config)
devices = DeviceRepository(db).get_devices_by_account_id(account_id)
for device in devices:
self.expire_device_location_etag_by_device_id(device.id)
def expire_device_setting_etag_by_account_id(self, account_id: str):
"""Expire the settings' etags for all devices from a given account. Used when the settings are updated
at account level"""
db = connect_to_db(self.db_connection_config)
devices = DeviceRepository(db).get_devices_by_account_id(account_id)
for device in devices:
self.expire_device_setting_etag_by_device_id(device.id)
def add_device(db, account_id, geography_id):
device = dict(
name="Selene Test Device",
pairing_code="ABC123",
placement="kitchen",
geography_id=geography_id,
country="United States",
region="Missouri",
city="Kansas City",
timezone="America/Chicago",
wake_word="hey selene",
voice="Selene Test Voice",
)
device_repository = DeviceRepository(db)
device_id = device_repository.add(account_id, device)
return device_id
def patch(self, device_id):
self._authenticate(device_id)
payload = json.loads(self.request.data)
update_device = UpdateDevice(payload)
update_device.validate()
updates = dict(platform=payload.get('platform') or 'unknown',
enclosure_version=payload.get('enclosureVersion')
or 'unknown',
core_version=payload.get('coreVersion') or 'unknown')
DeviceRepository(self.db).update_device_from_core(device_id, updates)
return '', HTTPStatus.OK
def get(self, device_id):
self._authenticate(device_id)
self._validate_etag(device_etag_key(device_id))
device = DeviceRepository(self.db).get_device_by_id(device_id)
if device is not None:
response_data = dict(uuid=device.id,
name=device.name,
description=device.placement,
coreVersion=device.core_version,
enclosureVersion=device.enclosure_version,
platform=device.platform,
user=dict(uuid=device.account_id))
response = response_data, HTTPStatus.OK
self._add_etag(device_etag_key(device_id))
else:
response = '', HTTPStatus.NO_CONTENT
return response
def _get_device(self, device_id):
device_repository = DeviceRepository(self.db)
device = device_repository.get_device_by_id(device_id)
response_data = self._format_device_for_response(device)
return response_data
def device_repository(self):
"""Lazily load an instance of the device repository"""
if self._device_repository is None:
self._device_repository = DeviceRepository(self.db)
return self._device_repository
def _delete_device(self, device_id):
device_repository = DeviceRepository(self.db)
device_repository.remove(device_id)
delete_device_login(device_id, self.cache)
def add_text_to_speech(db):
voice = _build_voice()
device_repository = DeviceRepository(db)
voice.id = device_repository.add_text_to_speech(voice)
return voice
def expire_skill_etag_by_account_id(self, account_id):
db = connect_to_db(self.db_connection_config)
devices = DeviceRepository(db).get_devices_by_account_id(account_id)
for device in devices:
self.expire_skill_etag_by_device_id(device.id)
def remove_text_to_speech(db, voice):
device_repository = DeviceRepository(db)
device_repository.remove_text_to_speech(voice.id)
def device_repository(self):
"""Lazily instantiate the device repository."""
if self._device_repository is None:
self._device_repository = DeviceRepository(self.db)
return self._device_repository
def add_wake_word(db):
wake_word = _build_wake_word()
device_repository = DeviceRepository(db)
wake_word.id = device_repository.add_wake_word(wake_word)
return wake_word
def remove_wake_word(db, wake_word):
device_repository = DeviceRepository(db)
device_repository.remove_wake_word(wake_word.id)
