def record_create_channel_event(event, context):
logger.info("Received request to initiate order")
try:
payload = json.loads(event["body"])
required_keys = [
"order_id", "sender", "signature", "r", "s", "v",
"current_block_no", "group_id", "org_id", "amount", "currency",
"recipient", "amount_in_cogs"
]
if validate_dict(payload, required_keys):
ChannelRepository().add_channel_transaction_history_record(
ChannelTransactionHistory(
order_id=payload["order_id"],
amount=payload["amount"],
currency=payload["currency"],
type=payload.get("type", "openChannelByThirdParty"),
address=payload["sender"],
recipient=payload["recipient"],
signature=payload["signature"],
org_id=payload["org_id"],
group_id=payload["group_id"],
request_parameters=payload.get("request_parameters", ""),
transaction_hash=payload.get("transaction_hash", ""),
status=TransactionStatus.NOT_SUBMITTED))
logger.info(f"Payload for create channel: {payload}")
response = wallet_service.record_create_channel_event(payload)
return generate_lambda_response(StatusCode.CREATED,
make_response_body(
ResponseStatus.SUCCESS,
response, {}),
cors_enabled=False)
else:
response = "Bad Request"
logger.error(f"response: {response}\n" f"event: {event}")
return generate_lambda_response(StatusCode.BAD_REQUEST,
make_response_body(
ResponseStatus.FAILED,
response, {}),
cors_enabled=False)
except Exception as e:
response = "Failed to record create channel event"
logger.error(f"response: {response}\n"
f"stage: {NETWORK_ID}"
f"event: {event}\n"
f"error: {repr(e)}")
utils.report_slack(str(repr(e)), SLACK_HOOK)
traceback.print_exc()
return generate_lambda_response(StatusCode.INTERNAL_SERVER_ERROR,
make_response_body(
ResponseStatus.FAILED, response,
Error.undefined_error(repr(e))),
cors_enabled=False)
def update_consumed_balance(event, context):
logger.info("Received request to update consumed balance")
try:
path_parameters = event["pathParameters"]
payload = json.loads(event["body"])
if validate_dict(
payload, ["OrganizationID", "ServiceID", "GroupID", "AuthorizedAmount",
"FullAmount", "ChannelId", "Nonce"]) \
and "channel_id" in path_parameters:
org_id = payload["OrganizationID"]
service_id = payload["ServiceID"]
group_id = payload["GroupID"]
authorized_amount = payload["AuthorizedAmount"]
full_amount = payload["FullAmount"]
nonce = payload["Nonce"]
channel_id = path_parameters["channel_id"]
logger.info(
f"Fetched values from request\n"
f"org_id: {org_id} group_id: {group_id} service_id: {service_id} "
f"authorized_amount: {authorized_amount} full_amount: {full_amount} nonce: {nonce}"
)
response = obj_mpe.update_consumed_balance(channel_id,
authorized_amount,
full_amount, nonce)
return generate_lambda_response(StatusCode.CREATED,
make_response_body(
ResponseStatus.SUCCESS,
response, {}),
cors_enabled=True)
else:
logger.error("Bad Request")
logger.info(event)
return generate_lambda_response(StatusCode.BAD_REQUEST,
make_response_body(
ResponseStatus.FAILED,
"Bad Request", {}),
cors_enabled=True)
except Exception as e:
response = "Failed to update consumed balance"
logger.error(response)
logger.info(event)
logger.error(e)
error = Error.undefined_error(repr(e))
utils.report_slack(str(error), SLACK_HOOK)
traceback.print_exc()
return generate_lambda_response(StatusCode.INTERNAL_SERVER_ERROR,
make_response_body(
ResponseStatus.FAILED, response,
error),
cors_enabled=True)
def create_channel(event, context):
logger.info("Received request to initiate order")
try:
payload = json.loads(event["body"])
required_keys = [
"order_id", "sender", "signature", "r", "s", "v",
"current_block_no", "group_id", "org_id", "amount", "currency",
"recipient", "amount_in_cogs"
]
if validate_dict(payload, required_keys):
logger.info(f"Payload for create channel: {payload}")
response = wallet_service.open_channel_by_third_party(
order_id=payload['order_id'],
sender=payload['sender'],
signature=payload['signature'],
r=payload['r'],
s=payload['s'],
v=payload['v'],
current_block_no=payload['current_block_no'],
group_id=payload['group_id'],
org_id=payload["org_id"],
recipient=payload['recipient'],
amount=payload['amount'],
currency=payload['currency'],
amount_in_cogs=payload['amount_in_cogs'])
return generate_lambda_response(StatusCode.CREATED,
make_response_body(
ResponseStatus.SUCCESS,
response, {}),
cors_enabled=False)
else:
response = "Bad Request"
logger.error(f"response: {response}\n" f"event: {event}")
return generate_lambda_response(StatusCode.BAD_REQUEST,
make_response_body(
ResponseStatus.FAILED,
response, {}),
cors_enabled=False)
except Exception as e:
response = "Failed create channel"
logger.error(f"response: {response}\n"
f"event: {event}\n"
f"error: {repr(e)}")
utils.report_slack(1, str(repr(e)), SLACK_HOOK)
traceback.print_exc()
return generate_lambda_response(StatusCode.INTERNAL_SERVER_ERROR,
make_response_body(
ResponseStatus.FAILED, response,
Error.undefined_error(repr(e))),
cors_enabled=False)
def delete_user_wallet(event, context):
query_parameters = event["queryStringParameters"]
username = query_parameters["username"]
wallet_service.remove_user_wallet(username)
return generate_lambda_response(StatusCode.CREATED, make_response_body(
ResponseStatus.SUCCESS, "OK", {}
), cors_enabled=False)
def execute(event, context):
logger.info("Received request to execute order")
try:
username = event["requestContext"]["authorizer"]["claims"]["email"]
payload = json.loads(event["body"])
required_keys = ["order_id", "payment_id", "payment_details"]
if validate_dict(payload, required_keys):
response = OrderService(obj_repo=repo).execute_order(
username, payload)
status_code = StatusCode.CREATED
status = ResponseStatus.SUCCESS
else:
status_code = StatusCode.BAD_REQUEST
status = ResponseStatus.FAILED
response = "Bad Request"
logger.error(response)
logger.info(event)
error = {}
except ChannelCreationFailed as e:
response = e.get_wallet_details()
logger.error(f"response: {response}\n"
f"event: {event}\n"
f"error: CHANNEL_CREATION_FAILED")
error = Error.CHANNEL_CREATION_FAILED
status = ResponseStatus.FAILED
status_code = StatusCode.INTERNAL_SERVER_ERROR
utils.report_slack(1, str(error), SLACK_HOOK)
except FundChannelFailed as e:
response = "Failed to fund channel"
logger.error(f"response: {response}\n"
f"event: {event}\n"
f"error: FUND_CHANNEL_FAILED")
error = Error.FUND_CHANNEL_FAILED
status = ResponseStatus.FAILED
status_code = StatusCode.INTERNAL_SERVER_ERROR
utils.report_slack(1, str(error), SLACK_HOOK)
except Exception as e:
response = "Failed to execute order"
logger.error(f"response: {response}\n"
f"event: {event}\n"
f"error: {repr(e)}")
error = Error.UNDEFINED_ERROR
status = ResponseStatus.FAILED
status_code = StatusCode.INTERNAL_SERVER_ERROR
utils.report_slack(1, str(error), SLACK_HOOK)
traceback.print_exc()
return generate_lambda_response(status_code,
make_response_body(status, response,
error),
cors_enabled=True)
def record_create_channel_event(event, context):
logger.info("Received request to initiate order")
try:
payload = json.loads(event["body"])
required_keys = [
"order_id", "sender", "signature", "r", "s", "v",
"current_block_no", "group_id", "org_id", "amount", "currency",
"recipient", "amount_in_cogs"
]
if validate_dict(payload, required_keys):
logger.info(f"Payload for create channel: {payload}")
response = wallet_service.record_create_channel_event(payload)
return generate_lambda_response(StatusCode.CREATED,
make_response_body(
ResponseStatus.SUCCESS,
response, {}),
cors_enabled=False)
else:
response = "Bad Request"
logger.error(f"response: {response}\n" f"event: {event}")
return generate_lambda_response(StatusCode.BAD_REQUEST,
make_response_body(
ResponseStatus.FAILED,
response, {}),
cors_enabled=False)
except Exception as e:
response = "Failed to record create channel event"
logger.error(f"response: {response}\n"
f"stage: {NETWORK_ID}"
f"event: {event}\n"
f"error: {repr(e)}")
utils.report_slack(1, str(repr(e)), SLACK_HOOK)
traceback.print_exc()
return generate_lambda_response(StatusCode.INTERNAL_SERVER_ERROR,
make_response_body(
ResponseStatus.FAILED, response,
Error.undefined_error(repr(e))),
cors_enabled=False)
def get(event, context):
logger.info("Received request to get orders for username")
try:
username = event["requestContext"]["authorizer"]["claims"]["email"]
order_id = None
path_parameters = event["pathParameters"]
if path_parameters is not None:
order_id = path_parameters["order_id"]
bad_request = False
if order_id is None:
logger.info(f"Getting all order details for user {username}")
response = OrderService(
obj_repo=repo).get_order_details_by_username(username)
else:
logger.info(f"Getting order details for order_id {order_id}")
if order_id is not None:
response = OrderService(
obj_repo=repo).get_order_details_by_order_id(
username=username, order_id=order_id)
else:
bad_request = True
error = {}
if bad_request:
status_code = StatusCode.BAD_REQUEST
status = ResponseStatus.FAILED
response = "Bad Request"
logger.error(f"response: {response}\n" f"event: {event}")
else:
status_code = StatusCode.CREATED
status = ResponseStatus.SUCCESS
except Exception as e:
response = "Failed to get orders"
logger.error(f"response: {response}\n"
f"event: {event}\n"
f"error: {repr(e)}")
error = Error.UNDEFINED_ERROR
status = ResponseStatus.FAILED
status_code = StatusCode.INTERNAL_SERVER_ERROR
utils.report_slack(1, str(error), SLACK_HOOK)
traceback.print_exc()
return generate_lambda_response(status_code,
make_response_body(status, response,
error),
cors_enabled=True)
def initiate(event, context):
logger.info("Received request to initiate order")
try:
username = event["requestContext"]["authorizer"]["claims"]["email"]
payload = json.loads(event["body"])
required_keys = ["price", "item_details", "payment_method"]
if validate_dict(payload, required_keys):
response = OrderService(obj_repo=repo).initiate_order(
username, payload)
status_code = StatusCode.CREATED
status = ResponseStatus.SUCCESS
else:
status_code = StatusCode.BAD_REQUEST
status = ResponseStatus.FAILED
error = {}
response = "Bad Request"
logger.error(f"response: {response}\n" f"event: {event}")
error = {}
except PaymentInitiateFailed:
response = "Failed to initiate order"
error = Error.PAYMENT_INITIATE_FAILED
logger.error(f"response: {response}\n"
f"event: {event}\n"
f"error: PAYMENT_INITIATE_FAILED")
status = ResponseStatus.FAILED
utils.report_slack(1, error, SLACK_HOOK)
status_code = StatusCode.INTERNAL_SERVER_ERROR
traceback.print_exc()
except Exception as e:
response = "Failed to initiate order"
logger.error(f"response: {response}\n"
f"event: {event}\n"
f"error: {repr(e)}")
traceback.print_exc()
error = Error.UNDEFINED_ERROR
status = ResponseStatus.FAILED
status_code = StatusCode.INTERNAL_SERVER_ERROR
utils.report_slack(1, str(error), SLACK_HOOK)
return generate_lambda_response(status_code,
make_response_body(status, response,
error),
cors_enabled=True)
def cancel(event, context):
logger.info("Received request for cancel order")
try:
path_parameters = event["pathParameters"]
bad_request = False
if path_parameters is None:
bad_request = True
else:
order_id = path_parameters.get("order_id", None)
if order_id is not None:
response = OrderService(
obj_repo=repo).cancel_order_for_given_order_id(order_id)
else:
bad_request = True
error = {}
if bad_request:
status_code = StatusCode.BAD_REQUEST
status = ResponseStatus.FAILED
response = "Bad Request"
logger.error(f"response: {response}\n" f"event: {event}")
else:
status_code = StatusCode.CREATED
status = ResponseStatus.SUCCESS
except Exception as e:
response = "Failed to cancel order"
error = Error.UNDEFINED_ERROR
status = ResponseStatus.FAILED
status_code = StatusCode.INTERNAL_SERVER_ERROR
logger.error(f"response: {response}\n"
f"event: {event}\n"
f"error: {repr(e)}")
utils.report_slack(1, error, SLACK_HOOK)
traceback.print_exc()
return generate_lambda_response(status_code,
make_response_body(status, response,
error),
cors_enabled=True)
