def get(self, request, app_id, function_name):
context = Util.get_context(request)
context['app_id'] = app_id
adapter = DjangoAdapter(app_id, request)
with adapter.open_api_logic() as logic_api:
function = logic_api.get_function(function_name)['item']
file_paths = logic_api.get_function_file_paths(function_name).get(
'file_paths', [])
handler_prefix = '/'.join(function['handler'].split('.')[:-1])
current_path = None
for file_path in file_paths:
if file_path.startswith(handler_prefix):
current_path = file_path
context['function'] = function
context['file_paths'] = file_paths
context['current_path'] = current_path
context['current_file'] = logic_api.get_function_file(
function_name, current_path).get('item')
return render(request,
'dashboard/app/logic_edit.html',
context=context)
def post(self, request, app_id, function_name):
context = Util.get_context(request)
context['app_id'] = app_id
cmd = request.POST.get('cmd', None)
adapter = DjangoAdapter(app_id, request)
with adapter.open_api_logic() as logic_api:
if cmd == 'get_function_file':
function_name = request.POST.get('function_name')
file_path = request.POST.get('file_path')
result = logic_api.get_function_file(function_name, file_path)
return JsonResponse(result)
elif cmd == 'put_function_file':
function_name = request.POST.get('function_name')
file_path = request.POST.get('file_path')
file_content = request.POST.get('file_content')
file_type = request.POST.get('file_type', 'text')
result = logic_api.put_function_file(function_name, file_path,
file_content, file_type)
allocate_resource_in_background(adapter)
return JsonResponse(result)
elif cmd == 'update_function':
function_name = request.POST.get('function_name', None)
description = request.POST.get('description', None)
handler = request.POST.get('handler', None)
runtime = request.POST.get('runtime', None)
sdk_config = get_sdk_config(adapter)
result = logic_api.update_function(function_name=function_name,
description=description,
handler=handler,
runtime=runtime,
sdk_config=sdk_config)
return JsonResponse(result)
elif cmd == 'get_function_file_paths':
function_name = request.POST.get('function_name')
item = logic_api.get_function_file_paths(function_name)
return JsonResponse(item)
def post(self, request, app_id):
context = Util.get_context(request)
context['app_id'] = app_id
adapter = DjangoAdapter(app_id, request)
with adapter.open_api_storage() as storage_api:
cmd = request.POST['cmd']
if cmd == 'upload_b64': # 분할 업로드
file_bin = request.FILES['file_bin']
file_name = request.POST['file_name']
parent_file_id = None
def divide_chunks(text, n):
for i in range(0, len(text), n):
yield text[i:i + n]
raw_base64 = file_bin.read()
raw_base64 = base64.b64encode(raw_base64)
raw_base64 = raw_base64.decode('utf-8')
base64_chunks = divide_chunks(raw_base64,
1024 * 1024 * 4) # 4mb
for base64_chunk in base64_chunks:
result = storage_api.upload_b64(parent_file_id, file_name,
base64_chunk)
parent_file_id = result.get('file_id')
return JsonResponse(result)
elif cmd == 'get_b64_info_items': # For admins
start_key = request.POST.get('start_key', None)
result = storage_api.get_b64_info_items(start_key,
reverse=True)
return JsonResponse(result)
elif cmd == 'delete_b64':
file_id = request.POST['file_id']
result = storage_api.delete_b64(file_id)
return JsonResponse(result)
elif cmd == 'get_policy_code':
mode = request.POST.get('mode')
result = storage_api.get_policy_code(mode)
return JsonResponse(result)
elif cmd == 'put_policy':
mode = request.POST.get('mode')
code = request.POST.get('code')
result = storage_api.put_policy(mode, code)
return JsonResponse(result)
elif cmd == 'get_file_rows':
start_key = request.POST.get('start_key', None)
result = storage_api.get_b64_info_items(start_key,
reverse=True)
template = loader.get_template(
'dashboard/app/component/storage_file_table_row.html')
files = result.get('items', [])
end_key = result.get('end_key', None)
context = {
'app_id': app_id,
'files': files,
}
result = {
'file_rows': template.render(context, request),
'end_key': end_key
}
return JsonResponse(result)
def post(self, request, app_id):
context = Util.get_context(request)
context['app_id'] = app_id
adapter = DjangoAdapter(app_id, request)
with adapter.open_api_database() as database_api:
cmd = request.POST['cmd']
if cmd == 'add_partition':
partition_name = request.POST['partition_name']
_ = database_api.create_partition(partition_name)
elif cmd == 'add_item':
partition = request.POST['partition']
read_groups = request.POST.getlist('read_groups[]')
write_groups = request.POST.getlist('write_groups[]')
_ = database_api.create_item(partition, {}, read_groups,
write_groups)
elif cmd == 'add_field':
item_id = request.POST['item_id']
field_name = request.POST['field_name']
field_value = request.POST['field_value']
field_type = request.POST['field_type']
if field_type == 'S':
field_value = str(field_value)
elif field_type == 'N':
field_value = Decimal(field_value)
elif field_type == 'L':
field_value = list(field_value)
_ = database_api.put_item_field(item_id, field_name,
field_value)
elif cmd == 'delete_partition':
partition_name = request.POST['partition_name']
_ = database_api.delete_partition(partition_name)
elif cmd == 'delete_partitions':
partitions = request.POST.getlist('partitions[]')
_ = database_api.delete_partitions(partitions)
elif cmd == 'get_items':
partition = request.POST['partition']
start_key = request.POST.get('start_key', None)
result = database_api.get_items(partition, start_key=start_key)
result = Util.encode_dict(result)
return JsonResponse(result)
elif cmd == 'get_item':
item_id = request.POST['item_id']
result = database_api.get_item(item_id)
result = Util.encode_dict(result)
return JsonResponse(result)
elif cmd == 'delete_item':
item_id = request.POST['item_id']
result = database_api.delete_item(item_id)
return JsonResponse(result)
elif cmd == 'delete_items':
item_ids = request.POST.getlist('item_ids[]')
result = database_api.delete_items(item_ids)
return JsonResponse(result)
elif cmd == 'delete_field':
item_id = request.POST['item_id']
field_name = request.POST['field_name']
result = database_api.put_item_field(item_id, field_name, None)
return JsonResponse(result)
elif cmd == 'delete_fields':
field_names = request.POST.getlist('field_names[]')
item_id = request.POST['item_id']
for field_name in field_names:
result = database_api.put_item_field(
item_id, field_name, None)
return JsonResponse(result)
elif cmd == 'get_item_count':
partition = request.POST['partition']
result = database_api.get_item_count(partition)
result = Util.encode_dict(result)
return JsonResponse(result)
elif cmd == 'query_items':
partition = request.POST['partition']
query = request.POST['query']
start_key = request.POST.get('start_key', None)
query = json.loads(query)
instructions = query['instructions']
result = database_api.query_items(partition, instructions,
start_key)
return JsonResponse(result)
elif cmd == 'get_policy_code':
partition_to_apply = request.POST.get('partition_to_apply')
mode = request.POST.get('mode')
result = database_api.get_policy_code(partition_to_apply, mode)
return JsonResponse(result)
elif cmd == 'put_policy':
partition_to_apply = request.POST.get('partition_to_apply')
mode = request.POST.get('mode')
code = request.POST.get('code')
result = database_api.put_policy(partition_to_apply, mode,
code)
return JsonResponse(result)
return redirect(request.path_info) # Redirect back
def post(self, request, app_id):
context = Util.get_context(request)
context['app_id'] = app_id
cmd = request.POST.get('cmd', None)
adapter = DjangoAdapter(app_id, request)
with adapter.open_api_logic() as logic_api:
if cmd == 'create_function':
zip_file = request.FILES['zip_file']
function_name = request.POST['function_name']
description = request.POST['description']
runtime = request.POST['runtime']
handler = request.POST['handler']
use_logging = request.POST['use_logging'] == 'true'
use_traceback = request.POST['use_traceback'] == 'true'
use_standalone = request.POST['use_standalone'] == 'true'
sdk_config = get_sdk_config(adapter, use_localhost=False)
zip_file.seek(0)
zip_file_bin = zip_file.read()
zip_file_bytes = zip_file_bin
zip_file_bin = base64.b64encode(zip_file_bin)
zip_file_bin = zip_file_bin.decode('utf-8')
if not description:
description = None
try:
requirements_text = get_requirements_text_from_zipfile(
zip_file_bytes)
except Exception as ex:
requirements_text = None
print(ex)
print(traceback.format_exc())
requirements_zip_file_id = None
response_stdout = None
if requirements_text:
print('requirements_text:', requirements_text)
with adapter.open_sdk() as sdk_client:
response = sdk_client.logic_create_packages_zip(
requirements_text)
print('logic_create_packages_zip:', response)
requirements_zip_file_id = response.get(
'zip_file_id', None)
response_stdout = response.get('response_stdout', None)
if not requirements_zip_file_id:
raise RuntimeError(
'Requirements.txt error! retry or check this.')
# response = logic_api.create_packages_zip(requirements_text)
# print('logic_create_packages_zip:', response)
# requirements_zip_file_id = response.get('zip_file_id', None)
response_function_creation = logic_api.create_function(
function_name, description, runtime, handler, sdk_config,
zip_file_bin, True, use_logging, use_traceback,
requirements_zip_file_id, use_standalone)
return JsonResponse({
'package_install_response_stdout':
response_stdout,
'response_function_creation':
response_function_creation
})
elif cmd == 'create_function_test':
test_name = request.POST.get('test_name')
function_name = request.POST.get('function_name')
test_input = request.POST.get('test_input')
logic_api.create_function_test(test_name, function_name,
test_input)
elif cmd == 'run_function':
with adapter.open_sdk() as sdk_client:
# TODO SDK Sign-up Login and authentication takes a lot of time.
# We are planning to store the SDK ID Password in the session.
function_name = request.POST.get('function_name')
payload = request.POST.get('payload')
payload = json.loads(payload)
start = time.time()
data = sdk_client.logic_run_function(
function_name, payload)
end = time.time()
data['duration'] = end - start
# print('data:', data)
return JsonResponse(data)
elif cmd == 'delete_function_test':
test_name = request.POST.get('test_name')
logic_api.delete_function_test(test_name)
elif cmd == 'delete_function':
function_name = request.POST.get('function_name')
function_version = request.POST.get('function_version', None)
logic_api.delete_function(function_name, function_version)
elif cmd == 'create_webhook':
name = request.POST.get('name')
description = request.POST.get('description')
function_name = request.POST.get('function_name')
logic_api.create_webhook(name, description, function_name)
elif cmd == 'delete_webhook':
name = request.POST.get('name')
logic_api.delete_webhook(name)
return redirect(request.path_info) # Redirect back
def post(self, request, app_id, marketplace_logic_id):
context = Util.get_context(request)
app = App.objects.get(id=app_id, user=request.user)
context['app_id'] = app_id
context['app_name'] = app.name
adapter = DjangoAdapter(app_id, request)
cmd = request.POST.get('cmd', None)
if cmd == 'edit_marketplace_logic':
title = request.POST.get('title')
description = request.POST.get('description')
category = request.POST.get('category')
logo_image = request.FILES.get('logo_image')
content = request.POST.get('content')
function_name = request.POST.get('function_name')
change_logo_image = request.POST.get('change_logo_image', False)
change_function = request.POST.get('change_function', False)
if change_logo_image == 'true':
change_logo_image = True
elif change_logo_image == 'false':
change_logo_image = False
if change_function == 'true':
change_function = True
elif change_function == 'false':
change_function = False
with adapter.open_api_logic() as logic_api:
logic_function = logic_api.get_function(function_name)['item']
handler = logic_function['handler']
runtime = logic_function['runtime']
function_zip_b64 = logic_api.get_function_zip_b64(
function_name)['item']['base64']
function_zip_b64 = function_zip_b64.encode('utf-8')
function_zip = base64.b64decode(function_zip_b64)
function_zip_name = '{}.zip'.format(function_name)
function_zip_file = SimpleUploadedFile(
function_zip_name, function_zip,
'application/octet-stream')
marketplace_logic = MarketplaceLogic.objects.get(
id=marketplace_logic_id, user=request.user)
marketplace_logic.title = title
marketplace_logic.description = description
marketplace_logic.category = category
if change_logo_image:
marketplace_logic.logo_image = logo_image
if change_function:
# Needs security verification by AWS-I team
marketplace_logic.verified = False
marketplace_logic.function_zip_file = function_zip_file
marketplace_logic.function_name = function_name
marketplace_logic.handler = handler
marketplace_logic.runtime = runtime
marketplace_logic.content = content
marketplace_logic.save()
return JsonResponse(
data={'marketplace_logic_id': marketplace_logic.id})
def post(self, request, app_id):
context = Util.get_context(request)
context['app_id'] = app_id
adapter = DjangoAdapter(app_id, request)
with adapter.open_api_auth() as api:
cmd = request.POST['cmd']
if cmd == 'delete_group':
name = request.POST['group_name']
error = api.delete_user_group(name).get('error', None)
if error:
Util.add_alert(
request, '{}: {}'.format(error['code'],
error['message']))
elif cmd == 'put_group':
name = request.POST['group_name']
description = request.POST['group_description']
api.put_user_group(name, description)
elif cmd == 'set_login_method':
login_method = request.POST['login_method']
default_group = request.POST['default_group_name']
enabled = request.POST['enabled']
register_policy_code = request.POST.get(
'register_policy_code', None)
if enabled == 'true':
enabled = True
else:
enabled = False
api.set_login_method(login_method, enabled, default_group,
register_policy_code)
elif cmd == 'put_user':
email = request.POST['user_email']
password = request.POST['user_password']
api.create_user(email, password, {})
elif cmd == 'delete_user':
user_id = request.POST['user_id']
api.delete_user(user_id)
elif cmd == 'delete_sessions':
session_ids = request.POST.getlist('session_ids[]')
api.delete_sessions(session_ids)
elif cmd == 'delete_users':
user_ids = request.POST.getlist('user_ids[]')
api.delete_users(user_ids)
elif cmd == 'detach_group_permission':
group_name = request.POST.get('group_name')
permission = request.POST.get('permission')
api.detach_group_permission(group_name, permission)
elif cmd == 'attach_group_permission':
group_name = request.POST.get('group_name')
permission = request.POST.get('permission')
api.attach_group_permission(group_name, permission)
elif cmd == 'set_users':
user_ids = request.POST.getlist('user_ids[]')
field_name = request.POST.get('field_name')
field_type = request.POST.get('field_type')
field_value = request.POST.get('field_value', None)
if field_type == 'S':
field_value = str(field_value)
elif field_type == 'N':
field_value = Decimal(field_value)
with ThreadPoolExecutor(max_workers=32) as exc:
for user_id in user_ids:
exc.submit(api.set_user, user_id, field_name,
field_value)
elif cmd == 'attach_user_group':
user_id = request.POST.get('user_id')
group_name = request.POST.get('group_name')
api.attach_user_group(user_id, group_name)
elif cmd == 'detach_user_group':
user_id = request.POST.get('user_id')
group_name = request.POST.get('group_name')
api.detach_user_group(user_id, group_name)
elif cmd == 'get_sessions':
start_key = request.POST.get('start_key', None)
result = api.get_sessions(start_key=start_key, limit=20)
return JsonResponse(result)
elif cmd == 'get_users':
start_key = request.POST.get('start_key', None)
result = api.get_users(start_key=start_key, limit=20)
return JsonResponse(result)
elif cmd == 'get_user_rows':
start_key = request.POST.get('start_key', None)
query = request.POST.getlist('query[]', [])
if start_key:
start_key = json.loads(start_key)
result = self._get_user_rows(request,
app_id,
start_key=start_key,
query=query)
return JsonResponse(result)
elif cmd == 'get_session_rows':
start_key = request.POST.get('start_key', None)
result = self._get_session_rows(request, app_id, start_key)
return JsonResponse(result)
elif cmd == 'set_group_session_security_enhancement':
group_name = request.POST.get('group_name')
enabled = request.POST.get('enabled')
if enabled == 'false':
enabled = False
elif enabled == 'true':
enabled = True
result = api.set_group_session_security_enhancement(
group_name, enabled)
return JsonResponse(result)
elif cmd == 'get_policy_code':
mode = request.POST.get('mode')
result = api.get_policy_code('user', mode)
print(result)
return JsonResponse(result)
elif cmd == 'put_policy':
mode = request.POST.get('mode')
code = request.POST.get('code')
result = api.put_policy('user', mode, code)
return JsonResponse(result)
return redirect(request.path_info) # Redirect back
def post(self, request, app_id):
cmd = request.POST.get('cmd', None)
adapter = DjangoAdapter(app_id, request)
with adapter.open_api_log() as log:
if cmd == 'get_logs':
start_key = request.POST.get('start_key', None)
event_source = request.POST.get('event_source', None)
event_name = request.POST.get('event_name', None)
event_param = request.POST.get('event_param', None)
user_id = request.POST.get('user_id', None)
log_result = log.get_logs(event_source,
event_name,
event_param,
user_id,
start_key,
limit=50)
return JsonResponse(log_result)
elif cmd == 'get_log_rows':
start_key = request.POST.get('start_key', None)
event_source = request.POST.get('event_source', None)
event_name = request.POST.get('event_name', None)
event_param = request.POST.get('event_param', None)
user_id = request.POST.get('user_id', None)
result = log.get_logs(event_source,
event_name,
event_param,
user_id,
start_key,
reverse=True,
limit=50)
template = loader.get_template(
'dashboard/app/component/log_table_row.html')
items = result.get('items', [])
def get_event_param(_event_param):
try:
if isinstance(_event_param, dict):
return json.dumps(json.loads(_event_param),
sort_keys=True,
indent=4)
except Exception as _:
pass
return str(_event_param)
items = [{
'owner':
item.get('owner', None),
'creation_date':
item.get('creation_date'),
'event_source':
item.get('event_source', None),
'event_name':
item.get('event_name', None),
'event_param':
get_event_param(item.get('event_param')),
} for item in items if item.get('event_param')]
end_key = result.get('end_key', None)
context = {
'items': items,
}
result = {
'rows': template.render(context, request),
'end_key': end_key
}
return JsonResponse(result)
