def delete_tv_bookmark_request(request, async_kvstore_client, request_context):
"""
Delete a TV bookmark
"""
try:
body = json.loads(request[constants.PAYLOAD])
bookmark_name = body.get(constants.NAME)
client_request_proto = request_pb2.ClientSingleRequest()
server_response_proto = request_pb2.ServerSingleResponse()
tv_bookmark_proto = client_request_proto.tvBookmarkDeleteRequest
tv_bookmark_proto.bookmarkName = bookmark_name
result = yield process_tv_bookmark_delete_request(request_context,
client_request_proto,
server_response_proto,
async_kvstore_client)
#defer.returnValue(result)
defer.returnValue(json.loads(MessageToJson(server_response_proto)))
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
#print(exc_type, fname, exc_tb.tb_lineno)
defer.returnValue('{} {} {} {}'.format(e.message, exc_type, fname, exc_tb.tb_lineno))
#defer.returnValue({'error': e.message})
defer.returnValue({'error': e.message})
defer.returnValue({'error': e.message})
async def dashboard_list_request(request, async_client_factory,
request_context):
"""
REST handler to fetch a list of dashboards
"""
try:
offset = request[QUERY].get(OFFSET)
max_results = request[QUERY].get(MAX_RESULTS)
dashboard_ids = request[QUERY].get(DASHBOARD_IDS)
minimal_list = int(request[QUERY].get(MINIMAL_LIST, 0))
client_request_proto = request_pb2.ClientSingleRequest()
dashboard_request = client_request_proto.dashboardListRequest
if dashboard_ids:
dashboard_ids = [
dashboard_ids
] if not isinstance(dashboard_ids, list) else dashboard_ids
dashboard_request.dashboardIds.extend(dashboard_ids)
if offset:
dashboard_request.offset = int(offset)
if max_results:
dashboard_request.maxResults = int(max_results)
dashboard_request.minimalList = minimal_list
server_response_proto = request_pb2.ServerSingleResponse()
await process_dashboard_list_request(request_context,
client_request_proto,
server_response_proto,
async_client_factory)
return MessageToDict(server_response_proto)
except Exception as e:
return {'error': str(e)}
def mpc_broadcast_request(request, async_client_factory, request_context):
"""
Tell a device to start MPC broadcasting
"""
try:
body = json.loads(request[constants.PAYLOAD])
device_id = body.get(constants.DEVICE_ID)
client_request_proto = request_pb2.ClientSingleRequest()
server_response_proto = request_pb2.ServerSingleResponse()
broadcast_proto = client_request_proto.startMPCBroadcastRequest
broadcast_proto.deviceId = device_id
result = yield process_mpc_broadcast_request(request_context,
client_request_proto,
server_response_proto,
async_client_factory)
#defer.returnValue(result)
defer.returnValue(json.loads(MessageToJson(server_response_proto)))
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
#print(exc_type, fname, exc_tb.tb_lineno)
defer.returnValue('{} {} {} {}'.format(e.message, exc_type, fname, exc_tb.tb_lineno))
defer.returnValue({'error': e.message})
def post_tv_config_request(request, async_client_factory, request_context):
"""
Set a TV config
"""
try:
body = json.loads(request[constants.PAYLOAD])
device_id = body.get(constants.DEVICE_ID, '')
device_name = body.get(constants.DEVICE_NAME, '')
mode = int(body.get(constants.MODE, constants.UNKNOWN_MODE))
tv_grid = body.get(constants.TV_GRID)
content = body.get(constants.CONTENT, '')
timestamp = body.get(constants.TIMESTAMP, 0)
captain_id = body.get(constants.CAPTAIN_ID, '')
captain_url = body.get(constants.CAPTAIN_URL, '')
input_tokens = body.get('input_tokens')
user_choices = body.get('user_choices')
client_request_proto = request_pb2.ClientSingleRequest()
server_response_proto = request_pb2.ServerSingleResponse()
tv_config = TVConfig(device_id=device_id,
device_name=device_name,
mode=mode,
content=content,
tv_grid=tv_grid,
timestamp=timestamp,
captain_id=captain_id,
captain_url=captain_url,
user_choices=user_choices,
input_tokens=input_tokens)
tv_config_proto = client_request_proto.tvConfigSetRequest.tvConfig
tv_config.set_protobuf(tv_config_proto)
result = yield process_tv_config_set_request(request_context,
client_request_proto,
server_response_proto,
async_client_factory)
#defer.returnValue(result)
defer.returnValue(json.loads(MessageToJson(server_response_proto)))
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
#print(exc_type, fname, exc_tb.tb_lineno)
defer.returnValue('{} {} {} {}'.format(e.message, exc_type, fname, exc_tb.tb_lineno))
def post_tv_config_bulk_request(request, async_client_factory, request_context):
"""
Set bulk tv config
"""
try:
body = json.loads(request[constants.PAYLOAD])
tv_list = body.get('tv_config_list', [])
client_request_proto = request_pb2.ClientSingleRequest()
server_response_proto = request_pb2.ServerSingleResponse()
proto_array = [TVConfig(**tv).to_protobuf() for tv in tv_list]
client_request_proto.tvConfigBulkSetRequest.tvConfig.extend(proto_array)
result = yield process_tv_config_bulk_set_request(request_context,
client_request_proto,
server_response_proto,
async_client_factory)
except Exception as e:
defer.returnValue({'error': e.message})
def tv_interaction_request(request, async_client_factory, request_context):
"""
Send a tv interaction to a device
"""
try:
body = json.loads(request[constants.PAYLOAD])
device_id = body.get(constants.DEVICE_ID)
client_request_proto = request_pb2.ClientSingleRequest()
server_response_proto = request_pb2.ServerSingleResponse()
tv_interaction_request = client_request_proto.tvInteractionRequest
tv_interaction_proto = tv_interaction_request.tvInteraction
tv_interaction_proto.device_id = device_id
if body.get('slideshow_go_to'):
tv_interaction_proto.slideshow_go_to.SetInParent()
elif body.get('slideshow_stop'):
tv_interaction_proto.slideshow_stop.SetInParent()
elif body.get('slideshow_forward'):
tv_interaction_proto.slideshow_forward.SetInParent()
elif body.get('slideshow_back'):
tv_interaction_proto.slideshow_back.SetInParent()
elif body.get('slideshow_speed'):
tv_interaction_proto.slideshow_speed.speed = int(body.get('slideshow_speed'))
else:
raise ValueError('invalid params')
result = yield process_tv_interaction_request(request_context,
client_request_proto,
server_response_proto,
async_client_factory)
#defer.returnValue(result)
defer.returnValue(json.loads(MessageToJson(server_response_proto)))
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
#print(exc_type, fname, exc_tb.tb_lineno)
defer.returnValue('{} {} {} {}'.format(e.message, exc_type, fname, exc_tb.tb_lineno))
defer.returnValue({'error': e.message})
def get_tv_request(request, async_kvstore_client, request_context):
"""
Retrieve either a list or a singular TVData instance
"""
try:
device_id = request[constants.QUERY].get(constants.DEVICE_ID)
client_request_proto = request_pb2.ClientSingleRequest()
tv_get_request = client_request_proto.tvGetRequest
if device_id:
tv_get_request.deviceId = device_id
server_response_proto = request_pb2.ServerSingleResponse()
result = yield process_tv_get_request(request_context,
client_request_proto,
server_response_proto,
async_kvstore_client)
defer.returnValue(json.loads(MessageToJson(server_response_proto, including_default_value_fields=True)))
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
#print(exc_type, fname, exc_tb.tb_lineno)
defer.returnValue('{} {} {} {}'.format(e.message, exc_type, fname, exc_tb.tb_lineno))
def get_app_list_request(request, async_client_factory, request_context):
"""
REST handler to fetch the selected app list for the current user
"""
try:
client_request_proto = request_pb2.ClientSingleRequest()
server_response_proto = request_pb2.ServerSingleResponse()
selected_apps = yield process_dashboard_app_list_get_request(request_context,
client_request_proto,
server_response_proto,
async_client_factory)
splunk_client = async_client_factory.splunk_client()
app_list = yield fetch_app_names(request_context, splunk_client)
app_dict = get_app_dict(app_list)
# This filters out apps that are invalid from displaying in the app selection tab
defer.returnValue({'app_list': [{'app_name': app, 'display_app_name': app_dict[app]} for app in selected_apps if app in app_dict]})
except Exception as e:
defer.returnValue({'error': e.message})
def delete_tv_config_request(request, async_client_factory, request_context):
"""
Delete a TV config
"""
try:
body = json.loads(request[constants.PAYLOAD])
device_id = body.get(constants.DEVICE_ID, [])
client_request_proto = request_pb2.ClientSingleRequest()
server_response_proto = request_pb2.ServerSingleResponse()
tv_config_proto = client_request_proto.tvConfigDeleteRequest
tv_config_proto.deviceId.extend(device_id)
result = yield process_tv_config_delete_request(request_context,
client_request_proto,
server_response_proto,
async_client_factory)
#defer.returnValue(result)
defer.returnValue(json.loads(MessageToJson(server_response_proto)))
except Exception as e:
defer.returnValue({'error': e.message})
def activate_tv_bookmark_request(request, async_client_factory, request_context):
"""
Activate a TV bookmark
"""
try:
body = json.loads(request[constants.PAYLOAD])
bookmark_name = body.get(constants.NAME)
client_request_proto = request_pb2.ClientSingleRequest()
server_response_proto = request_pb2.ServerSingleResponse()
tv_activate_bookmark_proto = client_request_proto.tvBookmarkActivateRequest
tv_activate_bookmark_proto.bookmarkName = bookmark_name
result = yield process_tv_bookmark_activate_request(request_context,
client_request_proto,
server_response_proto,
async_client_factory)
defer.returnValue(json.loads(MessageToJson(server_response_proto)))
except Exception as e:
defer.returnValue({'error': e.message})
def tv_captain_url_request(request, async_client_factory, request_context):
"""
Send a tv interaction to a device
"""
try:
body = json.loads(request[constants.PAYLOAD])
captain_id = body.get(constants.CAPTAIN_ID, '')
captain_url = body.get(constants.CAPTAIN_URL, '')
update_flag = body.get(constants.UPDATE_FLAG, False)
timestamp = body.get(constants.TIMESTAMP, 0)
client_request_proto = request_pb2.ClientSingleRequest()
server_response_proto = request_pb2.ServerSingleResponse()
captain_url_request = client_request_proto.tvCaptainUrlRequest
captain_url_request.captainId = captain_id
captain_url_request.captainUrl = captain_url
captain_url_request.updateFlag = update_flag
captain_url_request.timestamp = timestamp
result = yield process_tv_captain_url_request(request_context,
client_request_proto,
server_response_proto,
async_client_factory)
#defer.returnValue(result)
defer.returnValue(json.loads(MessageToJson(server_response_proto)))
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
#print(exc_type, fname, exc_tb.tb_lineno)
defer.returnValue('{} {} {} {}'.format(e.message, exc_type, fname, exc_tb.tb_lineno))
defer.returnValue({'error': e.message})
def post_app_list_request(request, async_client_factory, request_context):
"""
Update app list selection for current user
"""
try:
client_request_proto = request_pb2.ClientSingleRequest()
server_response_proto = request_pb2.ServerSingleResponse()
app_list_request = client_request_proto.dashboardAppListSetRequest
splunk_client = async_client_factory.splunk_client()
total_app_list = yield fetch_app_names(request_context, splunk_client)
app_list = validate_write_request(request, total_app_list)
app_list_request.appNames.extend(json.loads(app_list))
success = yield process_dashboard_app_list_set_request(request_context,
client_request_proto,
server_response_proto,
async_client_factory)
defer.returnValue(json.loads(MessageToJson(server_response_proto)))
except Exception as e:
defer.returnValue({'error': e.message})
def post_tv_bookmark_request(request, async_kvstore_client, request_context):
"""
Set a TV Bookmark
"""
try:
body = json.loads(request[constants.PAYLOAD])
description = body.get(constants.BOOKMARK_DESCRIPTION, '')
name = body.get(constants.NAME, '')
device_ids = body.get(constants.DEVICE_ID_LIST, [])
overwrite = body.get('overwrite', False)
client_request_proto = request_pb2.ClientSingleRequest()
server_response_proto = request_pb2.ServerSingleResponse()
request_proto = client_request_proto.tvBookmarkSetRequest
request_proto.deviceIds.extend(device_ids)
request_proto.description = description
request_proto.name = name
request_proto.overwrite = overwrite
result = yield process_tv_bookmark_set_request(request_context,
client_request_proto,
server_response_proto,
async_kvstore_client)
defer.returnValue(json.loads(MessageToJson(server_response_proto)))
except Exception as e:
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
#print(exc_type, fname, exc_tb.tb_lineno)
defer.returnValue('{} {} {} {}'.format(e.message, exc_type, fname, exc_tb.tb_lineno))
#defer.returnValue({'error': e.message})
defer.returnValue({'error': e.message})
