def _update_device(device, update_device_json, validate_required=True):
fields = ({
field['name']: field['value']
for field in update_device_json['fields']
} if 'fields' in update_device_json else None)
app = update_device_json['app_name']
device_type = update_device_json[
'type'] if 'type' in update_device_json else device.type
try:
device_api = get_app_device_api(app, device_type)
device_fields_api = device_api['fields']
if fields is not None:
validate_device_fields(device_fields_api,
fields,
device_type,
app,
validate_required=validate_required)
except (UnknownApp, UnknownDevice, InvalidArgument) as e:
return __crud_device_error_handler('update', e, app, device_type)
else:
if fields is not None:
fields = update_device_json[
'fields'] if 'fields' in update_device_json else None
add_configuration_keys_to_device_json(fields, device_fields_api)
device.update_from_json(update_device_json)
executiondb.execution_db.session.commit()
device_json = get_device_json_with_app_name(device)
# remove_configuration_keys_from_device_json(device_json)
return device_json, SUCCESS
def import_device(app, device, device_type, fields):
try:
device_api = get_app_device_api(app, device_type)
device_fields_api = device_api['fields']
validate_device_fields(device_fields_api, fields, device_type, app)
except UnknownDevice:
current_app.logger.error('Cannot import device for app {0}, type {1}. '
'Type does not exist'.format(
app, device_type))
except InvalidArgument as e:
current_app.logger.error('Cannot import device for app {0}, type {1}. '
'Invalid input'.format(
app, device_type,
format_exception_message(e)))
else:
fields = device['fields']
add_configuration_keys_to_device_json(fields, device_fields_api)
app = device_db.session.query(App).filter(App.name == app).first()
if app is not None:
device_obj = Device.from_json(device)
app.add_device(device_obj)
device_db.session.add(device_obj)
device_db.session.commit()
else:
current_app.logger.error(
'SEVERE: App defined in api does not have corresponding entry in database. '
'Cannot import device')
return app
def test_basic_device_fields_validation(self):
device_fields = [{
'name': 'param1',
'type': 'string'
}, {
'name': 'param2',
'type': 'boolean'
}]
device_in = {'param1': 'somevalue', 'param2': True}
validate_device_fields(device_fields, device_in, '', '')
def test_device_fields_validation_with_no_fields_none_required(self):
device_fields = [{
'name': 'param1',
'type': 'string'
}, {
'name': 'param2',
'type': 'boolean'
}]
device_in = {}
validate_device_fields(device_fields, device_in, '', '')
def test_device_fields_validation_with_some_required_in_api(self):
device_fields = [{
'name': 'param1',
'type': 'string',
'required': True
}, {
'name': 'param2',
'type': 'boolean'
}]
device_in = {'param1': 'somevalue', 'param2': True}
validate_device_fields(device_fields, device_in, '', '')
def test_basic_device_fields_validation_invalid_type(self):
device_fields = [{
'name': 'param1',
'type': 'string'
}, {
'name': 'param2',
'type': 'boolean'
}]
device_in = {'param1': 'somevalue', 'param2': 'invalid'}
with self.assertRaises(InvalidArgument):
validate_device_fields(device_fields, device_in, '', '')
def test_device_fields_validation_with_encryption_false(self):
device_fields = [{
'name': 'param1',
'type': 'string',
'encrypted': False
}, {
'name': 'param2',
'type': 'boolean'
}]
device_in = {'param1': 'somevalue', 'param2': True}
validate_device_fields(device_fields, device_in, '', '')
def test_device_fields_validation_with_encryption_with_invalid_value(self):
device_fields = [{
'name': 'param1',
'type': 'integer',
'encrypted': True
}, {
'name': 'param2',
'type': 'boolean'
}]
device_in = {'param1': 'somevalue', 'param2': True}
with self.assertRaises(InvalidArgument):
validate_device_fields(device_fields, device_in, '', '')
def test_device_fields_validation_with_some_required_in_api_too_few_fields(
self):
device_fields = [{
'name': 'param1',
'type': 'string',
'required': True
}, {
'name': 'param2',
'type': 'boolean'
}]
device_in = {'param2': True}
with self.assertRaises(InvalidArgument):
validate_device_fields(device_fields, device_in, '', '')
def __func():
if request.files and 'file' in request.files:
f = request.files['file']
add_device_json = json.loads(f.read().decode('utf-8'))
else:
add_device_json = request.get_json()
if current_app.running_context.execution_db.session.query(
Device).filter(Device.name ==
add_device_json['name']).first() is not None:
current_app.logger.error('Could not create device {0}. '
'Device already exists.'.format(
add_device_json['name']))
return Problem.from_crud_resource(
OBJECT_EXISTS_ERROR, 'device', 'create',
'Device with name {} already exists.'.format(
add_device_json['name']))
fields = {
field['name']: field['value']
for field in add_device_json['fields']
}
app = add_device_json['app_name']
device_type = add_device_json['type']
try:
device_api = get_app_device_api(app, device_type)
device_fields_api = device_api['fields']
validate_device_fields(device_fields_api, fields, device_type, app)
except (UnknownApp, UnknownDevice, InvalidArgument) as e:
return __crud_device_error_handler('create', e, app, device_type)
else:
fields = add_device_json['fields']
add_configuration_keys_to_device_json(fields, device_fields_api)
app = current_app.running_context.execution_db.session.query(
App).filter(App.name == app).first()
if app is None:
current_app.logger.error(
'SEVERE: App defined in api does not have corresponding entry in database. '
'Cannot add device')
return Problem.from_crud_resource(
INVALID_INPUT_ERROR, 'device', 'create',
'App {} does not exist.'.format(
add_device_json['app_name']))
device = Device.from_json(add_device_json)
app.add_device(device)
current_app.running_context.execution_db.session.add(device)
current_app.running_context.execution_db.session.commit()
device_json = get_device_json_with_app_name(device)
return device_json, OBJECT_CREATED
def test_device_fields_validation_with_defaults_with_required(self):
device_fields = [{'name': 'param1', 'type': 'string', 'encrypted': True},
{'name': 'param2', 'type': 'boolean', 'default': False, 'required': True}]
device_in = {'param1': 'somevalue'}
validated = validate_device_fields(device_fields, device_in, '', '')
device_in['param2'] = False
self.assertDictEqual(validated, device_in)
def __func():
if request.files and 'file' in request.files:
f = request.files['file']
add_device_json = json.loads(f.read().decode('utf-8'))
else:
add_device_json = request.get_json()
if current_app.running_context.execution_db.session.query(Device).filter(
Device.name == add_device_json['name']).first() is not None:
current_app.logger.error('Could not create device {0}. '
'Device already exists.'.format(add_device_json['name']))
return Problem.from_crud_resource(
OBJECT_EXISTS_ERROR,
'device',
'create',
'Device with name {} already exists.'.format(add_device_json['name']))
fields = {field['name']: field['value'] for field in add_device_json['fields']}
app = add_device_json['app_name']
device_type = add_device_json['type']
try:
device_api = get_app_device_api(app, device_type)
device_fields_api = device_api['fields']
validate_device_fields(device_fields_api, fields, device_type, app)
except (UnknownApp, UnknownDevice, InvalidArgument) as e:
return __crud_device_error_handler('create', e, app, device_type)
else:
fields = add_device_json['fields']
add_configuration_keys_to_device_json(fields, device_fields_api)
app = current_app.running_context.execution_db.session.query(App).filter(App.name == app).first()
if app is None:
current_app.logger.error('SEVERE: App defined in api does not have corresponding entry in database. '
'Cannot add device')
return Problem.from_crud_resource(
INVALID_INPUT_ERROR,
'device',
'create',
'App {} does not exist.'.format(add_device_json['app_name']))
device = Device.from_json(add_device_json)
app.add_device(device)
current_app.running_context.execution_db.session.add(device)
current_app.running_context.execution_db.session.commit()
device_json = get_device_json_with_app_name(device)
return device_json, OBJECT_CREATED
def _update_device(device, update_device_json, validate_required=True):
fields = ({field['name']: field['value'] for field in update_device_json['fields']}
if 'fields' in update_device_json else None)
app = update_device_json['app_name']
device_type = update_device_json['type'] if 'type' in update_device_json else device.type
try:
device_api = get_app_device_api(app, device_type)
device_fields_api = device_api['fields']
if fields is not None:
validate_device_fields(device_fields_api, fields, device_type, app, validate_required=validate_required)
except (UnknownApp, UnknownDevice, InvalidArgument) as e:
return __crud_device_error_handler('update', e, app, device_type)
else:
if fields is not None:
fields = update_device_json['fields'] if 'fields' in update_device_json else None
add_configuration_keys_to_device_json(fields, device_fields_api)
device.update_from_json(update_device_json, complete_object=validate_required)
current_app.running_context.execution_db.session.commit()
device_json = get_device_json_with_app_name(device)
return device_json, SUCCESS
def __func():
add_device_json = request.get_json()
if device_db.session.query(Device).filter(
Device.name == add_device_json['name']).first() is not None:
current_app.logger.error('Could not create device {0}. '
'Device already exists.'.format(
add_device_json['name']))
return {"error": "Device already exists."}, OBJECT_EXISTS_ERROR
fields = {
field['name']: field['value']
for field in add_device_json['fields']
}
app = add_device_json['app_name']
device_type = add_device_json['type']
try:
device_api = get_app_device_api(app, device_type)
device_fields_api = device_api['fields']
validate_device_fields(device_fields_api, fields, device_type, app)
except (UnknownApp, UnknownDevice, InvalidArgument) as e:
return __crud_device_error_handler('create', e, app, device_type)
else:
fields = add_device_json['fields']
add_configuration_keys_to_device_json(fields, device_fields_api)
app = device_db.session.query(App).filter(App.name == app).first()
if app is None:
current_app.logger.error(
'SEVERE: App defined in api does not have corresponding entry in database. '
'Cannot add device')
return {'error': 'Unknown app'}, INVALID_INPUT_ERROR
device = Device.from_json(add_device_json)
app.add_device(device)
device_db.session.add(device)
device_db.session.commit()
device_json = get_device_json_with_app_name(device)
# remove_configuration_keys_from_device_json(device_json)
return device_json, OBJECT_CREATED
def test_device_fields_validation_with_required_and_encrypted(self):
device_fields = [{'name': 'param1', 'type': 'string', 'required': True, 'encrypted': True},
{'name': 'param2', 'type': 'boolean'}]
device_in = {'param1': 'somevalue', 'param2': True}
validate_device_fields(device_fields, device_in, '', '')
def test_basic_device_fields_validation_invalid_type(self):
device_fields = [{'name': 'param1', 'type': 'string'}, {'name': 'param2', 'type': 'boolean'}]
device_in = {'param1': 'somevalue', 'param2': 'invalid'}
with self.assertRaises(InvalidArgument):
validate_device_fields(device_fields, device_in, '', '')
def test_basic_device_fields_validation(self):
device_fields = [{'name': 'param1', 'type': 'string'}, {'name': 'param2', 'type': 'boolean'}]
device_in = {'param1': 'somevalue', 'param2': True}
validate_device_fields(device_fields, device_in, '', '')
def test_device_fields_validation_with_some_required_in_api_too_few_fields(self):
device_fields = [{'name': 'param1', 'type': 'string', 'required': True},
{'name': 'param2', 'type': 'boolean'}]
device_in = {'param2': True}
with self.assertRaises(InvalidArgument):
validate_device_fields(device_fields, device_in, '', '')
def test_device_fields_validation_with_all_required_in_api(self):
device_fields = [{'name': 'param1', 'type': 'string', 'required': True},
{'name': 'param2', 'type': 'boolean', 'required': True}]
device_in = {'param1': 'somevalue', 'param2': True}
validate_device_fields(device_fields, device_in, '', '')
def test_device_fields_validation_with_encryption_with_invalid_value(self):
device_fields = [{'name': 'param1', 'type': 'integer', 'encrypted': True},
{'name': 'param2', 'type': 'boolean'}]
device_in = {'param1': 'somevalue', 'param2': True}
with self.assertRaises(InvalidArgument):
validate_device_fields(device_fields, device_in, '', '')
def test_device_fields_validation_with_no_fields_none_required(self):
device_fields = [{'name': 'param1', 'type': 'string'}, {'name': 'param2', 'type': 'boolean'}]
device_in = {}
validate_device_fields(device_fields, device_in, '', '')
