def get_resource_tree_data(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(
optional_params=["pageNumber", "pageSize", "datasourceId"])
if req_error:
return req_error
auth_token = req_session.get_auth_token()
payload = req_session.get_body()
accessible_by = payload.get("accessibleBy")
exposure_type = payload.get("exposureType")
resource_type = payload.get("resourceType")
page_number = payload.get("pageNumber")
page_size = payload.get("pageSize")
owner_email_id = payload.get("ownerEmailId")
parent_folder = payload.get("parentFolder")
selected_date = payload.get("selectedDate")
search_prefix = payload.get("prefix")
sort_column_name = payload.get("sortColumn")
sort_type = payload.get("sortType")
datasource_id = payload.get("datasourceId")
source_type = payload.get("sourceType")
resource_list = resource_controller.get_resources(
auth_token, page_number, page_size, accessible_by, exposure_type,
resource_type, search_prefix, owner_email_id, parent_folder,
selected_date, sort_column_name, sort_type, datasource_id, source_type)
return req_session.generate_sqlalchemy_response(200, resource_list)
def get_alert(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
alerts = alert_controller.get_alerts(req_session.get_auth_token())
return req_session.generate_sqlalchemy_response(200, alerts)
def get_user_stats(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(True)
if req_error:
return req_error
stats = directory_controller.get_user_stats(req_session.get_auth_token())
return req_session.generate_sqlalchemy_response(200, stats)
def post_user_app(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
apps = directory_controller.insert_apps(req_session.get_auth_token(), req_session.get_body())
return req_session.generate_sqlalchemy_response(201, apps)
def get_all_activities(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
activities = get_activites_for_domain(req_session.get_body())
return req_session.generate_sqlalchemy_response(200, activities)
def get_trusted_entities(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(True, ["domainId"])
if req_error:
return req_error
trusted_entities = domain_controller.get_all_trusted_entities(req_session.get_req_param("domainId"))
return req_session.generate_sqlalchemy_response(200, trusted_entities)
def post_trusted_entities(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
trusted_entities = domain_controller.create_trusted_entities_for_a_domain(req_session.get_auth_token(), req_session.get_body())
return req_session.generate_sqlalchemy_response(200, trusted_entities)
def get_audit_log(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(True)
if req_error:
return req_error
auth_token = req_session.get_auth_token()
audit_log_list = auditlog_controller.get_audit_log(auth_token)
return req_session.generate_sqlalchemy_response(200, audit_log_list)
def get_datasource(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
datasources = domain_controller.get_datasource(
req_session.get_auth_token(), None)
return req_session.generate_sqlalchemy_response(200, datasources)
def execute_gsuite_actions(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(True)
if req_error:
return req_error
response = gsuite_action_facade.execute_action(
req_session.get_auth_token(), req_session.get_body())
return req_session.generate_sqlalchemy_response(
response.get_response_code(), response.get_response_body())
def get_policies(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
policies = policy_controller.get_policies(req_session.get_auth_token())
return req_session.generate_sqlalchemy_response(200, policies)
def get_all_actions(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
auth_token = req_session.get_auth_token()
actions = actions_controller.get_actions()
return req_session.generate_sqlalchemy_response(200, actions)
def post_policy(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
policy = policy_controller.create_policy(req_session.get_auth_token(),
req_session.get_body())
return req_session.generate_sqlalchemy_response(201, policy)
def receive_slack_notifications(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(False,
mandatory_params=[],
optional_params=[])
if req_error:
return req_error
response = notifications_receiver.receive_notifications(
req_session.get_body())
return req_session.generate_sqlalchemy_response(202, response or {})
def post_datasource(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
try:
datasource = domain_controller.create_datasource(req_session.get_auth_token(), req_session.get_body())
except Exception as ex:
return req_session.generate_error_response(400, ex.message)
return req_session.generate_sqlalchemy_response(200, datasource)
def update_policy(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(True, ['policyId'])
if req_error:
return req_error
policy = policy_controller.update_policy(
req_session.get_auth_token(), req_session.get_req_param('policyId'),
req_session.get_body())
return req_session.generate_sqlalchemy_response(201, policy)
def get_widget_data(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(True)
if req_error:
return req_error
body = req_session.get_body()
data = reports_controller.get_widget_data(req_session.get_auth_token(),
body.get('widget_id'), None,
None, body.get('event_filters'))
return req_session.generate_sqlalchemy_response(200, data)
def get_activities_for_user(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(
mandatory_params=["user_email"])
if req_error:
return req_error
auth_token = req_session.get_auth_token()
user_email = req_session.get_req_param('user_email')
response = activities.get_activities_for_user(auth_token, user_email, None)
return req_session.generate_sqlalchemy_response(200, response)
def run_scheduled_report(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(True, ['reportId'])
if req_error:
return req_error
auth_token = req_session.get_auth_token()
response = reports_controller.run_report(
auth_token, req_session.get_req_param('reportId'))
return req_session.generate_sqlalchemy_response(200,
response['response_data'])
def get_group_members(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(
True, optional_params=["groupEmail", "datasourceId"])
if req_error:
return req_error
auth_token = req_session.get_auth_token()
group_email = req_session.get_req_param('groupEmail')
datasource_id = req_session.get_req_param('datasourceId')
group_members = directory_controller.get_group_members(
auth_token, group_email, datasource_id)
return req_session.generate_sqlalchemy_response(200, group_members)
def get_resources(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(
optional_params=["prefix", "pageNumber", "pageSize"])
if req_error:
return req_error
auth_token = req_session.get_auth_token()
page_number = req_session.get_req_param("pageNumber")
page_size = req_session.get_req_param("pageSize")
resource_list = resource_controller.get_resources(
auth_token, page_number, page_size, None, "", "",
req_session.get_req_param("prefix"))
return req_session.generate_sqlalchemy_response(200, resource_list)
def export_to_csv(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
response = directory_controller.export_to_csv(req_session.get_auth_token(),
req_session.get_body())
if response:
return req_session.generate_sqlalchemy_response(
response.response_code, response.get_response_body())
else:
return req_session.generate_response(202)
def initiate_action(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
auth_token = req_session.get_auth_token()
action_payload = req_session.get_body()
Logger().info("Initiating action using payload: " + str(action_payload))
response = actions_controller.initiate_action(auth_token, action_payload)
return req_session.generate_sqlalchemy_response(
response.response_code, response.get_response_body())
def current_user(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
user_session = auth_controller.get_user_session(
req_session.get_auth_token())
if not user_session:
return req_session.generate_error_response(401,
"User session not found")
else:
return req_session.generate_sqlalchemy_response(200, user_session)
def modify_scheduled_report(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
update_record = reports_controller.update_report(
req_session.get_auth_token(), req_session.get_body())
report_id = update_record['report_id']
frequency = update_record['frequency']
payload = {'report_id': report_id}
function_name = aws_utils.get_lambda_name('get',
urls.EXECUTE_SCHEDULED_REPORT)
aws_utils.create_cloudwatch_event(report_id, frequency, function_name,
payload)
return req_session.generate_sqlalchemy_response(201, update_record)
def get_users_list(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(optional_params=[
"full_name", "email", "member_type", "datasource_id", "sort_column",
"sort_order", "is_admin", "type", "page_number"
])
if req_error:
return req_error
users = directory_controller.get_users_list(
req_session.get_auth_token(), req_session.get_req_param("full_name"),
req_session.get_req_param("email"),
req_session.get_req_param("member_type"),
req_session.get_req_param("datasource_id"),
req_session.get_req_param("sort_column"),
req_session.get_req_param("sort_order"),
req_session.get_req_param("is_admin"),
req_session.get_req_param("type"),
req_session.get_req_param("page_number"))
return req_session.generate_sqlalchemy_response(200, users)
def post_scheduled_report(event, context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request()
if req_error:
return req_error
reports = reports_controller.create_report(req_session.get_auth_token(),
req_session.get_body())
for report in reports:
cron_expression = report.frequency
report_id = report.report_id
payload = {'report_id': report_id}
function_name = aws_utils.get_lambda_name(
'get', urls.EXECUTE_SCHEDULED_REPORT)
aws_utils.create_cloudwatch_event(report_id, cron_expression,
function_name, payload)
return req_session.generate_sqlalchemy_response(201, reports)
def get_user_app(event,context):
req_session = RequestSession(event)
req_error = req_session.validate_authorized_request(True,optional_params=["filterType", "appId", "domainId", "userEmail", "datasourceId", "pageNumber","pageSize","sortColumn","sortOrder","appName"])
if req_error:
return req_error
auth_token = req_session.get_auth_token()
filter_type = req_session.get_req_param('filterType')
data = {}
if filter_type == 'USER_APPS':
app_id = req_session.get_req_param('appId')
domain_id = req_session.get_req_param('domainId')
user_email = req_session.get_req_param('userEmail')
datasource_id = req_session.get_req_param('datasourceId')
sort_column_name = req_session.get_req_param("sortColumn")
sort_order = req_session.get_req_param("sortOrder")
if app_id:
data = directory_controller.get_users_for_app(auth_token, domain_id, app_id, sort_column_name, sort_order)
elif user_email:
data = directory_controller.get_apps_for_user(auth_token, datasource_id, user_email)
else:
data = directory_controller.get_all_apps(auth_token)
elif filter_type == 'INSTALLED_APPS':
app_name = req_session.get_req_param("appName")
page_number = req_session.get_req_param("pageNumber")
page_size = req_session.get_req_param("pageSize")
sort_column_name = req_session.get_req_param("sortColumn")
sort_order = req_session.get_req_param("sortOrder")
apps, total_count = app_controller.get_installed_apps(auth_token, page_number, page_size, app_name, sort_column_name, sort_order)
data = {'apps':apps, 'last_page':total_count}
elif filter_type == 'INVENTORY_APPS':
app_name = req_session.get_req_param("appName")
page_num = req_session.get_req_param("pageNumber")
page_size = req_session.get_req_param("pageSize")
apps, total_count = app_controller.get_inventory_apps(auth_token, page_num, page_size, app_name)
data = {'apps':apps, 'last_page':total_count}
return req_session.generate_sqlalchemy_response(200, data)
