def execute(self, database):
for device in DeviceDomain.get({'hid': 'dummy'}):
try:
hid = DeviceDomain.hid(device['manufacturer'], device['serialNumber'], device['model'])
DeviceDomain.update_one_raw(device['_id'], {'$set': {'hid': hid}})
except KeyError:
DeviceDomain.update_one_raw(device['_id'], {'$unset': {'hid': ''}, '$set': {'isUidSecured': False}})
def _execute_register(device: dict, created: str, log: list):
"""
Tries to POST the device and updates the `device` dict with the resource from the database; if the device could
not be uploaded the `device` param will contain the database version of the device, not the inputting one. This is
because the majority of the information of a device is immutable (in concrete the fields used to compute
the ETAG).
:param device: Inputting device. It is replaced (keeping the reference) with the db version.
:param created: Set the _created value to be the same for the device as for the register
:param log: A log where to append the resulting device if execute_register has been successful
:raise InnerRequestError: any internal error in the POST that is not about the device already existing.
"""
new = True
try:
if created:
device['created'] = created
db_device = execute_post_internal(Naming.resource(device['@type']),
device)
except InnerRequestError as e:
new = False
try:
db_device = _get_existing_device(e)
# We add a benchmark todo move to another place?
device['_id'] = db_device['_id']
ComponentDomain.benchmark(device)
external_synthetic_id_fields = pick(
device, *DeviceDomain.external_synthetic_ids)
# If the db_device was a placeholder
# We want to override it with the new device
if db_device.get('placeholder', False):
# Eve do not generate defaults from sub-resources
# And we really need the placeholder default set, specially when
# discovering a device
device['placeholder'] = False
# We create hid when we validate (wrong thing) so we need to manually set it here as we won't
# validate in this db operation
device['hid'] = DeviceDomain.hid(device['manufacturer'],
device['serialNumber'],
device['model'])
DeviceDomain.update_one_raw(db_device['_id'], {'$set': device})
elif not is_empty(external_synthetic_id_fields):
# External Synthetic identifiers are not intrinsically inherent
# of devices, and thus can be added later in other Snapshots
# Note that the device / post and _get_existing_device() have already validated those ids
DeviceDomain.update_one_raw(
db_device['_id'], {'$set': external_synthetic_id_fields})
except DeviceNotFound:
raise e
else:
log.append(db_device)
device.clear()
device.update(db_device)
device['new'] = new # Note that the device is 'cleared' before
return db_device
def _validate_type_hid(self, field, _):
"""
General validation for inserting devices (the name of the function is forced by Cerberus, not a good one).
- Tries to create hid and validates it.
- If hid cannot be created:
- If it has a parent, ensures that the device is unique.
- If it has not a parent, validates that the device has an user provided _id.
"""
from ereuse_devicehub.resources.device.component.domain import ComponentDomain
from ereuse_devicehub.resources.device.exceptions import DeviceNotFound
try:
from ereuse_devicehub.resources.device.domain import DeviceDomain
# todo this should not be done in the validation. Prove of this is that it needs to be done in
# register/hooks again for placeholders
self.document['hid'] = DeviceDomain.hid(
self.document['manufacturer'], self.document['serialNumber'],
self.document['model'])
except KeyError:
self.document['isUidSecured'] = False
if '_id' not in self.document: # We do not validate here the unique constraint of _id
if 'parent' in self.document:
with suppress(KeyError, DeviceNotFound):
component = ComponentDomain.get_similar_component(
self.document, self.document['parent'])
self._error('model',
json_util.dumps({'NotUnique': component}))
else:
# If device has no parent and no hid, user needs to: or provide _id or forcing creating it
if 'forceCreation' not in self.document or not self.document[
'forceCreation']:
self._error(
'_id', json_util.dumps({'NeedsId': self.document}))
# else: user forces us to create the device, it will be assigned an _id
# else: user provided _id. We accept this, however is unsecured.
else:
from ereuse_devicehub.resources.device.settings import HID_REGEX
self._validate_regex(HID_REGEX, field, self.document['hid'])
self._validate_unique(True, field, self.document['hid'])