def request_handler(event, context):
try:
valid_event = validate_dict(
data_dict=event,
required_keys=REQUIRED_KEYS_FOR_CANCEL_ORDER_EVENT)
if not valid_event:
return generate_lambda_response(400,
"Bad Request",
cors_enabled=True)
path_parameters = event.get("pathParameters", None)
order_service = OrderService(obj_repo=repo)
cancel_order_status = order_service.cancel_order_for_given_order_id(
order_id=path_parameters["order_id"])
response = generate_lambda_response(200, {
"status": "success",
"data": cancel_order_status
},
cors_enabled=True)
except Exception as e:
error_message = format_error_message(status="failed",
error=repr(e),
payload=payload_dict,
net_id=NETWORK_ID,
handler="cancel_order_handler")
obj_util.report_slack(1, error_message, SLACK_HOOK)
response = generate_lambda_response(500,
error_message,
cors_enabled=True)
traceback.print_exc()
return response
def wrapper(*args, **kwargs):
handler_name = decorator_kwargs.get("handler_name", func.__name__)
path = kwargs.get("event", {}).get("path", None)
path_parameters = kwargs.get("event", {}).get("pathParameters", {})
query_string_parameters = kwargs.get("event", {}).get(
"queryStringParameters", {})
body = kwargs.get("event", {}).get("body", "{}")
error_message = f"Error Reported! \n" \
f"network_id: {NETWORK_ID}\n" \
f"path: {path}, \n" \
f"handler: {handler_name} \n" \
f"pathParameters: {path_parameters} \n" \
f"queryStringParameters: {query_string_parameters} \n" \
f"body: {body} \n" \
f"x-ray-trace-id: None \n" \
f"error_description: \n"
try:
return func(*args, **kwargs)
except EXCEPTIONS as e:
exec_info = get_exec_info()
slack_message = f"```{error_message}{exec_info}```"
logger.exception(exec_info)
Utils().report_slack(type=0,
slack_msg=slack_message,
SLACK_HOOK=SLACK_HOOK)
return generate_lambda_response(
StatusCode.INTERNAL_SERVER_ERROR, {
"status": "failed",
"data": "",
"error": {
"code": 0,
"message": e.error_message,
"details": e.error_details
}
},
cors_enabled=True)
except Exception as e:
exec_info = get_exec_info()
slack_message = f"```{error_message}{exec_info}```"
logger.exception(exec_info)
Utils().report_slack(type=0,
slack_msg=slack_message,
SLACK_HOOK=SLACK_HOOK)
return generate_lambda_response(
StatusCode.INTERNAL_SERVER_ERROR, {
"status": "failed",
"data": "",
"error": {
"code": 0,
"message": repr(e),
"details": {}
}
},
cors_enabled=True)
def service_event_consumer_handler(event, context):
logger.info(f"Got Service Event {event}")
try:
service_event_consumer = get_service_event_consumer(event)
service_event_consumer.on_event(event)
return generate_lambda_response(200, StatusCode.OK)
except Exception as e:
logger.exception(f"error {str(e)} while processing event {event}")
util.report_slack(f"got error : {str(e)} \n for event : {event}", SLACK_HOOK)
return generate_lambda_response(500, str(e))
def mpe_event_consumer_handler(event, context):
logger.info(f"Got MPE Event {event}")
try:
MPEEventConsumer(NETWORKS[NETWORK_ID]["ws_provider"]).on_event(event)
return generate_lambda_response(200, StatusCode.OK)
except Exception as e:
logger.exception(f"error {str(e)} while processing event {event}")
util.report_slack(f"got error : {str(e)} \n for event : {event}", SLACK_HOOK)
return generate_lambda_response(500, str(e))
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 update_service_assets(event, context):
logger.info(f"Update service assets event :: {event}")
response = UpdateServiceAssets().validate_and_process_service_assets(payload=event)
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def execute(event, context):
logger.info("Received request to execute payment")
try:
payload = json.loads(event['body'])
path_parameters = event["pathParameters"]
if validate_dict(payload, ["payment_method", "payment_details"]) \
and validate_dict(path_parameters, ["order_id", "payment_id"]):
order_id = path_parameters["order_id"]
payment_id = path_parameters["payment_id"]
payment_method = payload["payment_method"]
payment_details = payload["payment_details"]
logger.info(f"Fetched values from the request,"
f"order_id: {order_id}\n"
f"payment_id: {payment_id}\n"
f"payment_method: {payment_method}\n"
f"payment_details: {payment_details}")
response = OrderManager().execute_payment_against_order(
order_id, payment_id, payment_details, payment_method)
status_code = StatusCode.CREATED
else:
status_code = StatusCode.BAD_REQUEST
response = "Bad Request"
logger.error(response)
logger.info(event)
except Exception as e:
response = "Failed to execute payment"
logger.error(response)
logger.info(event)
logger.error(e)
status_code = StatusCode.INTERNAL_SERVER_ERROR
utils.report_slack(
"ERROR",
f"got error : {response} \n {str(e)} \n for event : {event} ",
SLACK_HOOK)
return generate_lambda_response(status_code=status_code, message=response)
def create(event, context):
logger.info("Received request to create order")
try:
payload = json.loads(event['body'])
if validate_dict(payload, ["price", "username"]):
amount = payload["price"]["amount"]
currency = payload["price"]["currency"]
username = payload["username"]
item_details = payload["item_details"]
logger.info(f"Fetched values from request\n"
f"username: {username}\n"
f"amount: {amount} {currency}\n"
f"item_details: {item_details}")
response = OrderManager().create_order(amount, currency,
item_details, username)
status_code = StatusCode.CREATED
else:
status_code = StatusCode.BAD_REQUEST
response = "Bad Request"
logger.error(response)
logger.info(event)
except Exception as e:
response = "Failed to create order"
logger.error(response)
logger.info(event)
logger.error(e)
status_code = StatusCode.INTERNAL_SERVER_ERROR
utils.report_slack(
f"got error : {response} \n {str(e)} \n for event : {event} ",
SLACK_HOOK)
return generate_lambda_response(status_code=status_code, message=response)
def get_channels_for_group(event, context):
group_id = event['pathParameters']['groupId']
channel_id = event['pathParameters']['channelId']
response_data = obj_mpe.get_channel_data_by_group_id_and_channel_id(
group_id=group_id, channel_id=channel_id)
return generate_lambda_response(
200, {"status": "success", "data": response_data}, cors_enabled=True)
def get_order_from_order_id(event, context):
logger.info("Received request to get order using order id")
try:
if "order_id" in event["pathParameters"]:
order_id = event["pathParameters"]["order_id"]
logger.info(f"Fetched values from request\n"
f"order_id: {order_id}")
response = OrderManager().get_order_from_order_id(order_id)
status_code = StatusCode.OK
else:
status_code = StatusCode.BAD_REQUEST
response = "Bad Request"
logger.error(response)
logger.info(event)
except Exception as e:
response = "Internal Server Error"
logger.error(response)
logger.info(event)
logger.error(e)
status_code = StatusCode.INTERNAL_SERVER_ERROR
utils.report_slack(
"ERROR",
f"got error : {response} \n {str(e)} \n for event : {event} ",
SLACK_HOOK)
return generate_lambda_response(status_code=status_code, message=response)
def get_verifications(event, context):
query_parameters = event["queryStringParameters"]
if "type" not in query_parameters:
raise BadRequestException()
response = VerificationManager().get_verifications(query_parameters)
return generate_lambda_response(StatusCode.OK, {"status": ResponseStatus.SUCCESS, "data": response, "error": {}},
cors_enabled=True)
def signature_to_get_free_call_from_daemon_handler(event, context):
logger.info(f"Request for freecall token event {event}")
signer = Signer(net_id=NET_ID)
payload_dict = event.get("queryStringParameters")
email = payload_dict["username"]
org_id = payload_dict["org_id"]
service_id = payload_dict["service_id"]
group_id = unquote(payload_dict["group_id"])
#public_key = payload_dict["public_key"]
logger.info(
f"Free call signature for daemon generation for email:{email} org_id:{org_id} service_id:{service_id} group_id:{group_id}"
)
token_to_get_free_call, expiry_date_block, signature, current_block_number, daemon_endpoint, free_calls_allowed = signer.token_to_get_free_call(
email, org_id, service_id, group_id)
signature_data = {
"token_to_get_free_call": token_to_get_free_call.hex(),
"expiry_date_block": expiry_date_block,
"signature": signature.hex(),
"current_block_number": current_block_number,
"daemon_endpoint": daemon_endpoint,
"free_calls_allowed": free_calls_allowed
}
return generate_lambda_response(200, {
"status": "success",
"data": signature_data
},
cors_enabled=True)
def cancel(event, context):
logger.info("Received request to cancel payment")
try:
path_parameters = event["pathParameters"]
if validate_dict(path_parameters, ["order_id", "payment_id"]):
order_id = path_parameters["order_id"]
payment_id = path_parameters["payment_id"]
response = OrderManager().cancel_payment_against_order(order_id, payment_id)
status_code = StatusCode.CREATED
else:
status_code = StatusCode.BAD_REQUEST
response = "Bad Request"
logger.error(response)
logger.info(event)
except Exception as e:
response = "Failed to cancel payment"
logger.error(response)
logger.info(event)
logger.error(e)
status_code = StatusCode.INTERNAL_SERVER_ERROR
utils.report_slack(f"got error : {response} \n {str(e)} \n for event : {event} ", SLACK_HOOK)
return generate_lambda_response(
status_code=status_code,
message=response
)
def get_channels(event, context):
logger.info("Received request to get channel details from user address")
try:
query_string_parameters = event["queryStringParameters"]
if validate_dict(query_string_parameters, ["wallet_address"]):
wallet_address = query_string_parameters["wallet_address"]
logger.info(
f"Fetched values from request wallet_address: {wallet_address}"
)
response = obj_mpe.get_channels_by_user_address_v2(wallet_address)
status_code = StatusCode.OK
else:
status_code = StatusCode.BAD_REQUEST
response = "Bad Request"
logger.error(response)
logger.info(event)
except Exception as e:
logger.info(event)
response = repr(e)
utils.report_slack(str(response), SLACK_HOOK)
logger.error(e)
status_code = StatusCode.INTERNAL_SERVER_ERROR
return generate_lambda_response(status_code=status_code,
message=response,
cors_enabled=True)
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 initiate(event, context):
logger.info("Received request for initiate payment")
try:
payload = json.loads(event['body'])
path_parameters = event["pathParameters"]
if validate_dict(payload, ["price", "payment_method"]) \
and validate_dict(path_parameters, ["order_id"]):
order_id = path_parameters["order_id"]
amount = payload["price"]["amount"]
currency = payload["price"]["currency"]
payment_method = payload["payment_method"]
logger.info(f"Fetched values from request\n"
f"order_id: {order_id}\n"
f"amount: {amount} {currency}\n"
f"payment_method: {payment_method}")
response = OrderManager().initiate_payment_against_order(order_id, amount, currency, payment_method)
status_code = StatusCode.CREATED
else:
status_code = StatusCode.BAD_REQUEST
response = "Bad Request"
logger.error(response)
logger.info(event)
except Exception as e:
logger.info(event)
response = "Failed to initiate payment"
logger.error(response)
logger.error(e)
status_code = StatusCode.INTERNAL_SERVER_ERROR
utils.report_slack(f"got error : {response} \n {str(e)} \n for event : {event} ", SLACK_HOOK)
return generate_lambda_response(
status_code=status_code,
message=response
)
def get_daemon_config_for_current_network(event, context):
logger.info(f"event for get_daemon_config_for_current_network:: {event}")
username = event["requestContext"]["authorizer"]["claims"]["email"]
path_parameters = event["pathParameters"]
query_parameters = event["queryStringParameters"]
if not validate_dict(path_parameters,
["org_uuid", "service_uuid", "group_id"
]) or 'network' not in query_parameters:
raise BadRequestException()
org_uuid = path_parameters["org_uuid"]
service_uuid = path_parameters["service_uuid"]
group_id = path_parameters["group_id"]
if query_parameters["network"] == EnvironmentType.TEST.value:
response = ServicePublisherService(
username, org_uuid,
service_uuid).daemon_config(environment=EnvironmentType.TEST.value)
elif query_parameters["network"] == EnvironmentType.MAIN.value:
response = ServicePublisherService(
username, org_uuid,
service_uuid).daemon_config(environment=EnvironmentType.MAIN.value)
else:
raise EnvironmentNotFoundException()
return generate_lambda_response(StatusCode.OK, {
"status": "success",
"data": response,
"error": {}
},
cors_enabled=True)
def get_order_details_for_user(event, context):
logger.info("Received request to get order details using username")
try:
if "username" in event["queryStringParameters"]:
username = event["queryStringParameters"]["username"]
logger.info(f"Fetched values from request\n"
f"username: {username}")
response = OrderManager().get_order_details_for_user(username)
status_code = StatusCode.OK
else:
status_code = StatusCode.BAD_REQUEST
response = "Bad Request"
logger.error(response)
logger.info(event)
except Exception as e:
response = "Failed to fetch order details"
logger.error(response)
logger.info(event)
logger.error(e)
status_code = StatusCode.INTERNAL_SERVER_ERROR
utils.report_slack(
"ERROR",
f"got error : {response} \n {str(e)} \n for event : {event} ",
SLACK_HOOK)
return generate_lambda_response(status_code=status_code, message=response)
def get_all_org(event, context):
obj_reg = Registry(obj_repo=db)
response_data = obj_reg.get_all_org()
return generate_lambda_response(200, {
"status": "success",
"data": response_data
},
cors_enabled=True)
def monitor_current_stake_window(event, context):
MonitorStakingData().monitor_current_stake_window_details()
return generate_lambda_response(StatusCode.OK, {
"status": "success",
"data": {},
"error": {}
},
cors_enabled=True)
def monitor_stake_for_all_stake_addresses(event, context):
MonitorStakingData().monitor_stake_for_all_stake_addresses()
return generate_lambda_response(StatusCode.OK, {
"status": "success",
"data": {},
"error": {}
},
cors_enabled=True)
def delete_user(event, context):
username = event["requestContext"]["authorizer"]["claims"]["email"]
user_service = UserService()
response = user_service.delete_user(username=username)
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def get_verification_transaction_data(event, context):
payload = event["body"]
response = verification_service.get_verification_transaction(
payload=payload)
return generate_lambda_response(StatusCode.OK, {
"status": ResponseStatus.SUCCESS,
"data": response
})
def get_stake_calculator_details(event, context):
response = StakeService.get_stake_calculator_details()
return generate_lambda_response(StatusCode.OK, {
"status": "success",
"data": response,
"error": {}
},
cors_enabled=True)
def get_stake_windows_schedule(event, context):
response = StakeService().get_stake_windows_schedule()
return generate_lambda_response(StatusCode.OK, {
"status": "success",
"data": response,
"error": {}
},
cors_enabled=True)
def get_all_org(event, context):
logger.info(event)
username = event["requestContext"]["authorizer"]["claims"]["email"]
response = OrganizationPublisherService(None, username).get_all_org_for_user()
return generate_lambda_response(
StatusCode.OK,
{"status": "success", "data": response, "error": {}}, cors_enabled=True
)
def get_service_post(event, context):
obj_reg = Registry(obj_repo=db)
payload_dict = json.loads(event['body'])
response_data = obj_reg.get_all_srvcs(qry_param=payload_dict)
return generate_lambda_response(200, {
"status": "success",
"data": response_data
},
cors_enabled=True)
def dummy_for_redirection(event, context):
return generate_lambda_response(
StatusCode.FOUND, {},
headers={
"location":
"http://ropsten-publisher.singularitynet.io.s3-website-us-east-1.amazonaws.com/enroll",
"Referrer-Policy": "unsafe-url"
},
cors_enabled=True)
