def apiv1_notifications_ack_get(webinterface, request, session,
notification_id):
try:
webinterface._Notifications.ack(notification_id)
except KeyError as e:
return return_not_found(request)
return return_good(request)
def apiv1_notifications_ack_get(webinterface, request, session, notification_id):
session.has_access("notification", "*", "view", raise_error=True)
try:
webinterface._Notifications.ack(notification_id)
except KeyError as e:
return return_not_found(request)
return return_good(request)
def apiv1_device_command_get_post(webinterface, request, session,
device_id, command_id):
try:
wait_time = float(request.args.get('_wait')[0])
except:
wait_time = 2
arguments = args_to_dict(request.args)
if 'inputs' in arguments:
inputs = arguments['inputs']
else:
inputs = None
if device_id in webinterface._Devices:
device = webinterface._Devices[device_id]
else:
return return_not_found(request, 'device not found')
# print("inputs: %s" % inputs)
try:
request_id = device.command(
cmd=command_id,
requested_by={
'user_id': session.user_id,
'component':
'yombo.gateway.lib.webinterface.routes.api_v1.devices.device_command',
'gateway': webinterface.gateway_id()
},
inputs=inputs,
)
except KeyError as e:
return return_not_found(request, 'Error with command: %s' % e)
DC = webinterface._Devices.device_commands[request_id]
if wait_time > 0:
exit_while = False
start_time = time()
while (start_time > (time() - wait_time)
and exit_while is False):
yield sleep(.075)
if DC.status_id >= 100:
exit_while = True
if len(device.status_history) > 0:
status_current = device.status_history[0].asdict()
else:
status_current = None
if len(device.status_history) > 1:
status_previous = device.status_history[1].asdict()
else:
status_previous = None
return return_good(request,
payload={
'device_command_id': request_id,
'device_command': DC.asdict(),
'status_current': status_current,
'status_previous': status_previous,
})
def apiv1_device_do_command_get_post(webinterface, request, session, device_command_id):
if device_command_id in webinterface._Devices.device_commands:
device_command = webinterface._Devices.device_commands[device_command_id]
return return_good(
request,
payload=device_command.asdict()
)
return return_not_found(request, 'Error with device command id: %s' % device_command_id)
def apiv1_gateway_details_get(webinterface, request, session,
gateway_id):
session.has_access("gateway", gateway_id, "view", raise_error=True)
if len(gateway_id) > 50 or isinstance(gateway_id, str) is False:
return return_error(request, "invalid gateway_id format", 400)
if gateway_id in webinterface._Gateways:
gateway = webinterface._Gateways[gateway_id]
return return_good(request, payload=gateway.asdict())
def apiv1_notifications_ack_get(webinterface, request, session,
notification_id):
webinterface._Validate.id_string(notification_id)
session.is_allowed(AUTH_PLATFORM_NOTIFICATION, "view",
notification_id)
try:
webinterface._Notifications.ack(notification_id)
except KeyError as e:
return return_not_found(request)
return return_good(request)
def apiv1_system_tools_ping(webinterface, request):
try:
request_id = request.args.get('id')[0]
except Exception as e:
request_id = random_string(length=12)
return return_good(request,
payload={
'id': request_id,
'time': float(time()),
})
def apiv1_device_details_get(webinterface, request, session,
device_id):
arguments = args_to_dict(request.args)
if device_id in webinterface._Devices:
device = webinterface._Devices[device_id]
else:
return return_not_found(request, 'device not found')
payload = device.asdict()
if 'item' in arguments:
payload = payload[arguments['item']]
return return_good(request, payload=payload)
def apiv1_automation_list_items_get(webinterface, request, session):
try:
platform = request.args.get('platform')[0]
except:
return return_error(request, 'platform must be specified.')
# try:
# type = request.args.get('type')[0]
# except:
# return return_error('type must be specified.')
webinterface._Automation.get_available_items(platform=platform)
a = return_good(request, 'The list')
request.setHeader('Content-Type', 'application/json')
return json.dumps(a)
def apiv1_device_command_getone_get(webinterface, request, session, device_command_id):
session.has_access("device_command", device_command_id, "view", raise_error=True)
if device_command_id in webinterface._DeviceCommands.device_commands:
device_command = webinterface._DeviceCommands.device_commands[device_command_id]
return webinterface.render_api(request, None,
data_type="device_commands",
attributes=device_command(device_command.asdict())
)
return return_good(
request,
payload=device_command.asdict()
)
return return_not_found(request, f"Error with device command id: {device_command_id}")
def apiv1_device_details_get(webinterface, request, session,
device_id):
session.has_access("device", device_id, "view", raise_error=True)
arguments = args_to_dict(request.args)
if len(device_id) > 200 or isinstance(device_id, str) is False:
return return_error(request, "invalid device_id format", 400)
if device_id in webinterface._Devices:
device = webinterface._Devices[device_id]
else:
return return_not_found(request, "Device not found")
payload = device.asdict()
if "item" in arguments:
payload = payload[arguments["item"]]
return return_good(request, payload=payload)
def apiv1_system_tools_uptime(webinterface, request, session):
if webinterface.starting == True:
return return_error(request, payload='Not ready yet.')
try:
request_id = str(request.args.get('timeonly')[0])
if request_id == '1':
return str(webinterface._Atoms['running_since'])
except Exception as e:
pass
try:
request_id = request.args.get('id')[0]
except Exception as e:
request_id = random_string(length=12)
return return_good(request,
payload={
'id':
request_id,
'time':
str(webinterface._Atoms['running_since']),
})
def apiv1_notifications_get(webinterface, request, session):
session.is_allowed(AUTH_PLATFORM_NOTIFICATION, "view")
return return_good(request,
"".webinterface.notifications.notifications)
def apiv1_device_get(webinterface, request, session):
return return_good(
request,
payload=webinterface._Devices.full_list_devices(),
)
def apiv1_gateway_get(webinterface, request, session):
session.has_access("gateway", "*", "view", raise_error=True)
return return_good(
request, payload=webinterface._Gateways.full_list_gateways())
def apiv1_command_get(webinterface, request, session):
return return_good(
request, payload=webinterface._Commands.full_list_commands())
def apiv1_module_get(webinterface, request, session):
modules = yield webinterface._Modules.full_list_modules()
return return_good(request, payload=modules)
def apiv1_device_command_get_post(webinterface, request, session,
device_id, command_id):
session.has_access("device",
device_id,
"control",
raise_error=True)
if len(device_id) > 200 or isinstance(device_id, str) is False:
return return_error(request, "invalid device_id format", 400)
if len(command_id) > 200 or isinstance(command_id, str) is False:
return return_error(request, "invalid command_id format", 400)
try:
wait_time = float(request.args.get("_wait")[0])
except:
wait_time = 2
arguments = args_to_dict(request.args)
pin_code = arguments.get("pin_code", None)
delay = arguments.get("delay", None)
max_delay = arguments.get("max_delay", None)
not_before = arguments.get("not_before", None)
not_after = arguments.get("not_after", None)
inputs = arguments.get("inputs", None)
if device_id in webinterface._Devices:
device = webinterface._Devices[device_id]
else:
return return_not_found(request, "Device not found")
try:
device_command_id = device.command(
cmd=command_id,
auth=session,
pin=pin_code,
delay=delay,
max_delay=max_delay,
not_before=not_before,
not_after=not_after,
inputs=inputs,
idempotence=request.idempotence,
)
except KeyError as e:
print(
f"error with apiv1_device_command_get_post keyerror: {e}")
return return_not_found(
request, f"Error with command, it is not found: {e}")
except YomboWarning as e:
print(f"error with apiv1_device_command_get_post warning: {e}")
return return_error(request, f"Error with command: {e}")
DC = webinterface._DeviceCommands.device_commands[
device_command_id]
if wait_time > 0:
exit_while = False
start_time = time()
while (start_time > (time() - wait_time)
and exit_while is False):
yield sleep(.075)
if DC.status_id >= 100:
exit_while = True
if len(device.status_history) > 0:
status_current = device.status_history[0].asdict()
else:
status_current = None
if len(device.status_history) > 1:
status_previous = device.status_history[1].asdict()
else:
status_previous = None
return return_good(request,
payload={
"device_command_id": device_command_id,
"device_command": DC.asdict(),
"status_current": status_current,
"status_previous": status_previous,
})
def apiv1_notifications_get(webinterface, request, session):
return return_good(request,
''.webinterface.notifications.notifications)
def apiv1_gateway_get(webinterface, request, session):
return return_good(
request, payload=webinterface._Gateways.full_list_gateways())
def apiv1_module_get(webinterface, request, session):
session.has_access("module", "*", "view", raise_error=True)
modules = yield webinterface._Modules.full_list_modules()
return return_good(request, payload=modules)
def apiv1_notifications_get(webinterface, request, session):
session.has_access("notification", "*", "view", raise_error=True)
return return_good(request, "". webinterface.notifications.notifications)
