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)