class WalletService:
def __init__(self, repo):
self.repo = repo
self.boto_utils = BotoUtils(region_name=REGION_NAME)
self.blockchain_util = BlockChainUtil(
provider_type="HTTP_PROVIDER",
provider=NETWORKS[NETWORK_ID]['http_provider'])
self.utils = Utils()
self.channel_dao = ChannelDAO(repo=self.repo)
self.wallet_dao = WalletDAO(repo=self.repo)
def create_and_register_wallet(self, username):
address, private_key = self.blockchain_util.create_account()
wallet = Wallet(address=address,
private_key=private_key,
type=GENERAL_WALLET_TYPE,
status=WalletStatus.ACTIVE.value)
self._register_wallet(wallet, username)
return wallet.to_dict()
def _register_wallet(self, wallet, username):
existing_wallet = self.wallet_dao.get_wallet_details(wallet)
if len(existing_wallet) == 0:
self.wallet_dao.insert_wallet(wallet)
self.wallet_dao.add_user_for_wallet(wallet, username)
def register_wallet(self, wallet_address, wallet_type, status, username):
wallet = Wallet(address=wallet_address,
type=wallet_type,
status=status)
self._register_wallet(wallet, username)
return wallet.to_dict()
def remove_user_wallet(self, username):
self.wallet_dao.remove_user_wallet(username)
def get_wallet_details(self, username):
""" Method to get wallet details for a given username. """
logger.info(f"Fetching wallet details for {username}")
wallet_data = self.wallet_dao.get_wallet_data_by_username(username)
self.utils.clean(wallet_data)
logger.info(
f"Fetched {len(wallet_data)} wallets for username: {username}")
wallet_response = {"username": username, "wallets": wallet_data}
return wallet_response
def __generate_signature_details(self, recipient, group_id, agi_tokens,
expiration, message_nonce, signer_key):
data_types = [
"string", "address", "address", "address", "address", "bytes32",
"uint256", "uint256", "uint256"
]
values = [
"__openChannelByThirdParty", self.mpe_address,
self.EXECUTOR_WALLET_ADDRESS, SIGNER_ADDRESS, recipient, group_id,
agi_tokens, expiration, message_nonce
]
signature = self.blockchain_util.generate_signature(
data_types=data_types, values=values, signer_key=signer_key)
v, r, s = Web3.toInt(
hexstr="0x" +
signature[-2:]), signature[:66], "0x" + signature[66:130]
return r, s, v, signature
def __calculate_amount_in_cogs(self, amount, currency):
if currency == "USD":
amount_in_cogs = round(amount)
else:
raise Exception("Currency %s not supported.", currency)
return amount_in_cogs
def record_create_channel_event(self, payload):
current_time = datetime.utcnow().strftime("%Y-%m-%d %H:%M:%S")
if not self.channel_dao.persist_create_channel_event(
payload, current_time):
raise Exception("Failed to create record")
return {}
def open_channel_by_third_party(self, order_id, sender, signature, r, s, v,
group_id, org_id, amount, currency,
recipient, current_block_no,
amount_in_cogs):
self.EXECUTOR_WALLET_ADDRESS = self.boto_utils.get_ssm_parameter(
EXECUTOR_ADDRESS)
self.EXECUTOR_WALLET_KEY = self.boto_utils.get_ssm_parameter(
EXECUTOR_KEY)
method_name = "openChannelByThirdParty"
self.mpe_address = self.blockchain_util.read_contract_address(
net_id=NETWORK_ID, path=MPE_ADDR_PATH, key='address')
# 1 block no is mined in 15 sec on average, setting expiration as 10 years
expiration = current_block_no + (10 * 365 * 24 * 60 * 4)
# amount_in_cogs = self.__calculate_amount_in_cogs(amount=amount, currency=currency)
self.__validate__cogs(amount_in_cogs=amount_in_cogs)
group_id_in_hex = "0x" + base64.b64decode(group_id).hex()
positional_inputs = (sender, SIGNER_ADDRESS, recipient,
group_id_in_hex, amount_in_cogs, expiration,
current_block_no, v, r, s)
transaction_object = self.blockchain_util.create_transaction_object(
*positional_inputs,
method_name=method_name,
address=self.EXECUTOR_WALLET_ADDRESS,
contract_path=MPE_CNTRCT_PATH,
contract_address_path=MPE_ADDR_PATH,
net_id=NETWORK_ID)
raw_transaction = self.blockchain_util.sign_transaction_with_private_key(
transaction_object=transaction_object,
private_key=self.EXECUTOR_WALLET_KEY)
transaction_hash = self.blockchain_util.process_raw_transaction(
raw_transaction=raw_transaction)
logger.info(
"openChannelByThirdParty::transaction_hash : %s for order_id : %s",
transaction_hash, order_id)
self.channel_dao.insert_channel_history(
order_id=order_id,
amount=amount,
currency=currency,
group_id=group_id,
org_id=org_id,
type=method_name,
recipient=recipient,
address=sender,
signature=signature,
request_parameters=str(positional_inputs),
transaction_hash=transaction_hash,
status=TransactionStatus.PENDING)
return {
"transaction_hash": transaction_hash,
"signature": signature,
"amount_in_cogs": amount_in_cogs,
"type": method_name
}
def set_default_wallet(self, username, address):
self.wallet_dao.set_default_wallet(username=username, address=address)
return "OK"
def add_funds_to_channel(self, org_id, group_id, channel_id, sender,
recipient, order_id, amount, currency,
amount_in_cogs):
self.EXECUTOR_WALLET_ADDRESS = self.boto_utils.get_ssm_parameter(
EXECUTOR_ADDRESS)
self.EXECUTOR_WALLET_KEY = self.boto_utils.get_ssm_parameter(
EXECUTOR_KEY)
method_name = "channelAddFunds"
# amount_in_cogs = self.__calculate_amount_in_cogs(amount=amount, currency=currency)
self.__validate__cogs(amount_in_cogs=amount_in_cogs)
positional_inputs = (channel_id, amount_in_cogs)
transaction_object = self.blockchain_util.create_transaction_object(
*positional_inputs,
method_name=method_name,
address=self.EXECUTOR_WALLET_ADDRESS,
contract_path=MPE_CNTRCT_PATH,
contract_address_path=MPE_ADDR_PATH,
net_id=NETWORK_ID)
raw_transaction = self.blockchain_util.sign_transaction_with_private_key(
transaction_object=transaction_object,
private_key=self.EXECUTOR_WALLET_KEY)
transaction_hash = self.blockchain_util.process_raw_transaction(
raw_transaction=raw_transaction)
logger.info("channelAddFunds::transaction_hash: %s for order_id: %s",
transaction_hash, order_id)
self.channel_dao.insert_channel_history(
order_id=order_id,
amount=amount,
currency=currency,
group_id=group_id,
org_id=org_id,
type=method_name,
recipient=recipient,
address=sender,
signature=None,
request_parameters=str(positional_inputs),
transaction_hash=transaction_hash,
status=TransactionStatus.PENDING)
return {
"transaction_hash": transaction_hash,
"amount_in_cogs": amount_in_cogs,
"type": method_name
}
def get_transactions_from_username_recipient(self, username, org_id,
group_id):
logger.info(
f"Fetching transactions for {username} to org_id: {org_id} group_id: {org_id}"
)
channel_data = self.channel_dao.get_channel_transactions_for_username_recipient(
username=username, group_id=group_id, org_id=org_id)
self.utils.clean(channel_data)
logger.info(f"Fetched {len(channel_data)} transactions")
transaction_details = {"username": username, "wallets": []}
wallet_transactions = dict()
for rec in channel_data:
sender_address = rec["address"]
if rec["address"] not in wallet_transactions:
wallet_transactions[rec["address"]] = {
"address": sender_address,
"is_default": rec["is_default"],
"type": rec["type"],
"transactions": []
}
if rec['recipient'] is None:
continue
transaction = {
"org_id": org_id,
"group_id": group_id,
"recipient": rec["recipient"],
"amount": rec["amount"],
"transaction_type": rec["transaction_type"],
"currency": rec["currency"],
"status": rec["status"],
"created_at": rec["created_at"],
}
wallet_transactions[sender_address]["transactions"].append(
transaction)
for key in wallet_transactions:
wallet = wallet_transactions[key]
transaction_details["wallets"].append(wallet)
return transaction_details
def get_channel_transactions_against_order_id(self, order_id):
transaction_history = self.channel_dao.get_channel_transactions_against_order_id(
order_id)
for record in transaction_history:
record["created_at"] = record["created_at"].strftime(
"%Y-%m-%d %H:%M:%S")
return {"order_id": order_id, "transactions": transaction_history}
def __validate__cogs(self, amount_in_cogs):
if amount_in_cogs < MINIMUM_AMOUNT_IN_COGS_ALLOWED:
raise Exception(
"Insufficient amount to buy minimum amount in cogs allowed.")
class OrderService:
def __init__(self, obj_repo):
self.repo = obj_repo
self.obj_transaction_history_dao = TransactionHistoryDAO(self.repo)
self.lambda_client = boto3.client('lambda', region_name=REGION_NAME)
self.boto_client = BotoUtils(REGION_NAME)
self.wallet_service = WalletService()
self.obj_blockchain_util = BlockChainUtil(
provider_type="HTTP_PROVIDER",
provider=NETWORKS[NETWORK_ID]['http_provider']
)
self.utils = Utils()
def initiate_order(self, username, payload_dict):
"""
Initiate Order
Step 1 Order Creation
Step 2 Initiate Payment
Step 3 Persist Transaction History
"""
price = payload_dict["price"]
order_type = payload_dict["item_details"]["order_type"]
item_details = payload_dict["item_details"]
group_id = item_details["group_id"]
org_id = item_details["org_id"]
channel_id = ""
amount_in_cogs = self.calculate_amount_in_cogs(amount=price["amount"], currency=price["currency"])
if amount_in_cogs < 1:
raise Exception("Amount in cogs should be greater than equal to 1")
item_details["amount_in_cogs"] = amount_in_cogs
if order_type == OrderType.CREATE_WALLET_AND_CHANNEL.value:
item_details["wallet_address"] = ""
recipient = self.get_payment_address_for_org(group_id=group_id, org_id=org_id)
elif order_type == OrderType.CREATE_CHANNEL.value:
recipient = self.get_payment_address_for_org(group_id=group_id, org_id=org_id)
elif order_type == OrderType.FUND_CHANNEL.value:
channel = self.get_channel_for_topup(username=username, group_id=group_id, org_id=org_id)
if channel is None:
raise Exception(f"Channel not found for the user: {username} with org: {org_id} group: {group_id}")
recipient = channel["recipient"]
channel_id = channel["channel_id"]
item_details["wallet_address"] = channel["address"]
else:
raise Exception("Invalid order type")
item_details["channel_id"] = channel_id
item_details["recipient"] = recipient
order_details = self.manage_create_order(
username=username, item_details=item_details,
price=price
)
order_id = order_details["order_id"]
try:
payment_data = self.manage_initiate_payment(
username=username, order_id=order_id, price=price,
payment_method=payload_dict["payment_method"]
)
payment_id = payment_data["payment_id"]
raw_payment_data = json.dumps(payment_data["payment"])
obj_transaction_history = TransactionHistory(
username=username, order_id=order_id, order_type=order_type,
payment_id=payment_id, raw_payment_data=raw_payment_data,
status=Status.PAYMENT_INITIATED.value
)
self.obj_transaction_history_dao.insert_transaction_history(obj_transaction_history=obj_transaction_history)
return payment_data
except Exception as e:
obj_transaction_history = TransactionHistory(
username=username, order_id=order_id, order_type=order_type,
status=Status.PAYMENT_INITIATION_FAILED.value
)
self.obj_transaction_history_dao.insert_transaction_history(obj_transaction_history=obj_transaction_history)
print(repr(e))
raise e
def get_channel_for_topup(self, username, group_id, org_id):
channel_details = self.wallet_service.get_channel_details(
username=username, group_id=group_id, org_id=org_id
)
wallets = channel_details["wallets"]
for wallet in wallets:
if (wallet["type"] == "GENERAL") and len(wallet["channels"]) > 0:
if wallet["channels"][0]["signer"] == SIGNER_ADDRESS:
wallet_address = wallet["address"]
channel = wallet["channels"][0]
channel["address"] = wallet_address
return channel
return None
def get_payment_address_for_org(self, org_id, group_id):
group_details_event = {
"path": f"/org/{org_id}/group/{quote(group_id, safe='')}",
"pathParameters": {
"orgId": org_id,
"group_id": quote(group_id, safe='')
},
"httpMethod": "GET"
}
logger.info(f"get_group_for_org request: {org_id} and {group_id}")
group_details_lambda_response = self.lambda_client.invoke(
FunctionName=GET_GROUP_FOR_ORG_API_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(group_details_event)
)
group_details_response = json.loads(group_details_lambda_response.get('Payload').read())
logger.info(f"get_group_for_org response: {group_details_response}")
if group_details_response["statusCode"] != 200:
raise Exception(f"Failed to fetch group details for org_id:{org_id} "
f"group_id {group_id}")
group_details_response_body = json.loads(group_details_response["body"])
groups = group_details_response_body["data"]["groups"]
if len(groups) == 0:
raise Exception(f"Failed to find group {group_id} for org_id: {org_id}")
return groups[0]["payment"]["payment_address"]
def calculate_amount_in_cogs(self, amount, currency):
if currency == "USD":
amount_in_cogs = round(amount * USD_TO_COGS_CONVERSION_FACTOR)
return amount_in_cogs
else:
raise Exception("Currency %s not supported.", currency)
def execute_order(self, username, payload_dict):
"""
Execute Order
Step 1 Execute Payment
Step 2 Get Receipient Address
Step 3 Process Order
Step 4 Update Transaction History
"""
order_id = payload_dict["order_id"]
payment_id = payload_dict["payment_id"]
order = self.get_order_details_by_order_id(order_id, username)
payment = None
for payment_item in order["payments"]:
if payment_item["payment_id"] == payment_id:
payment = payment_item
break
if payment is None:
raise Exception(f"Failed to fetch order details for order_id {order_id} \n"
f"payment_id {payment_id} \n"
f"username{username}")
order_type = order["item_details"]["order_type"]
item_details = order["item_details"]
payment_method = payment["payment_details"]["payment_method"]
paid_payment_details = payload_dict["payment_details"]
price = payment["price"]
status = Status.PAYMENT_EXECUTION_FAILED.value
self.manage_execute_payment(
username=username, order_id=order_id, payment_id=payment_id,
payment_details=paid_payment_details, payment_method=payment_method
)
status = Status.PAYMENT_EXECUTED.value
try:
status = Status.ORDER_PROCESSING_FAILED.value
amount_in_cogs = self.calculate_amount_in_cogs(amount=price["amount"], currency=price["currency"])
if amount_in_cogs < 1:
raise Exception("Amount in cogs should be greater than equal to 1")
processed_order_data = self.manage_process_order(
username=username,
order_id=order_id, order_type=order_type,
amount=price["amount"],
currency=price["currency"], order_data=item_details,
amount_in_cogs=amount_in_cogs
)
status = Status.ORDER_PROCESSED.value
obj_transaction_history = TransactionHistory(
username=username, order_id=order_id, order_type=order_type,
status=status, payment_id=payment_id,
payment_method=payment_method,
raw_payment_data=json.dumps(paid_payment_details)
)
self.obj_transaction_history_dao.insert_transaction_history(obj_transaction_history=obj_transaction_history)
processed_order_data["price"] = price
processed_order_data["item_details"] = item_details
return processed_order_data
except Exception as e:
obj_transaction_history = TransactionHistory(
username=username, order_id=order_id,
order_type=order_type, status=status
)
self.obj_transaction_history_dao.insert_transaction_history(obj_transaction_history=obj_transaction_history)
print(repr(e))
raise e
def get_order_details_by_order_id(self, order_id, username):
order_details_event = {
"path": f"order/{order_id}",
"pathParameters": {"order_id": order_id},
"httpMethod": "GET"
}
logger.info(f"Requesting order details for order_id {order_id}")
response = self.lambda_client.invoke(
FunctionName=ORDER_DETAILS_ORDER_ID_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(order_details_event)
)
order_details_response = json.loads(response.get('Payload').read())
if order_details_response["statusCode"] != 200:
raise Exception(f"Failed to fetch order details for order_id {order_id} username{username}")
order_details_data = json.loads(order_details_response["body"])
if order_details_data["username"] != username:
raise Exception(f"Failed to fetch order details for order_id {order_id} username{username}")
return order_details_data
def manage_initiate_payment(self, username, order_id, price, payment_method):
initiate_payment_event = {
"pathParameters": {"order_id": order_id},
"httpMethod": "POST",
"body": json.dumps({"price": price, "payment_method": payment_method})
}
response = self.lambda_client.invoke(
FunctionName=INITIATE_PAYMENT_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(initiate_payment_event)
)
initiate_payment_data = json.loads(response.get('Payload').read())
if initiate_payment_data["statusCode"] == 201:
return json.loads(initiate_payment_data["body"])
else:
logger.error("Error initiating payment for user %s", username)
raise PaymentInitiateFailed
def manage_create_order(self, username, item_details, price):
create_order_event = {
"path": "/order/create",
"httpMethod": "POST",
"body": json.dumps({"price": price, "item_details": item_details, "username": username})
}
create_order_service_response = self.boto_client.invoke_lambda(
lambda_function_arn=CREATE_ORDER_SERVICE_ARN,
invocation_type='RequestResponse',
payload=json.dumps(create_order_event)
)
logger.info(f"create_order_service_response: {create_order_service_response}")
if create_order_service_response["statusCode"] == 201:
return json.loads(create_order_service_response["body"])
else:
raise Exception(f"Error creating order for user {username}")
def manage_execute_payment(self, username, order_id, payment_id, payment_details, payment_method):
execute_payment_event = {
"pathParameters": {"order_id": order_id, "payment_id": payment_id},
"body": json.dumps({"payment_method": payment_method, "payment_details": payment_details})
}
response = self.lambda_client.invoke(
FunctionName=EXECUTE_PAYMENT_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(execute_payment_event)
)
payment_executed = json.loads(response.get('Payload').read())
if payment_executed["statusCode"] == 201:
return payment_executed
else:
raise Exception(f"Error executing payment for username {username} against order_id {order_id}")
def manage_process_order(self, username, order_id, order_type, amount, currency, order_data, amount_in_cogs):
logger.info(f"Order Data {order_data}")
group_id = order_data["group_id"]
org_id = order_data["org_id"]
recipient = order_data["recipient"]
channel_id = order_data["channel_id"]
sender = order_data["wallet_address"]
if order_type == OrderType.CREATE_WALLET_AND_CHANNEL.value:
wallet_create_payload = {
"path": "/wallet",
"body": json.dumps({"username": username}),
"httpMethod": "POST"
}
wallet_create_lambda_response = self.lambda_client.invoke(
FunctionName=WALLETS_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(wallet_create_payload)
)
wallet_create_response = json.loads(wallet_create_lambda_response.get("Payload").read())
if wallet_create_response["statusCode"] != 200:
raise Exception("Failed to create wallet")
wallet_create_response_body = json.loads(wallet_create_response["body"])
wallet_details = wallet_create_response_body["data"]
try:
current_block_no = self.obj_blockchain_util.get_current_block_no()
# 1 block no is mined in 15 sec on average, setting expiration as 10 years
expiration = current_block_no + (10 * 365 * 24 * 60 * 4)
message_nonce = current_block_no
self.EXECUTOR_WALLET_ADDRESS = self.boto_client.get_ssm_parameter(EXECUTOR_ADDRESS)
group_id_in_hex = "0x" + base64.b64decode(group_id).hex()
signature_details = self.generate_signature_for_open_channel_for_third_party(
recipient=recipient, group_id=group_id_in_hex,
amount_in_cogs=amount_in_cogs, expiration=expiration,
message_nonce=message_nonce, sender_private_key=wallet_details["private_key"],
executor_wallet_address=self.EXECUTOR_WALLET_ADDRESS
)
logger.info(f"Signature Details {signature_details}")
open_channel_body = {
'order_id': order_id,
'sender': wallet_details["address"],
'signature': signature_details["signature"],
'r': signature_details["r"],
's': signature_details["s"],
'v': signature_details["v"],
'group_id': group_id,
'org_id': org_id,
'amount': amount,
'currency': currency,
'recipient': recipient,
'current_block_no': current_block_no,
'amount_in_cogs': amount_in_cogs
}
channel_details = self.wallet_service.create_channel(open_channel_body=open_channel_body)
channel_details.update(wallet_details)
return channel_details
except Exception as e:
logger.error("Failed to create channel")
logger.error(repr(e))
response = {
"transaction_hash": "",
"signature": "",
"amount_in_cogs": 0,
"price": {
"amount": amount,
"currency": currency
},
"item_details": order_data
}
response.update(wallet_details)
raise ChannelCreationFailed("Failed to create channel", wallet_details=response)
elif order_type == OrderType.CREATE_CHANNEL.value:
try:
logger.info(f"Order Data {order_data}")
signature = order_data["signature"]
v, r, s = Web3.toInt(hexstr="0x" + signature[-2:]), signature[:66], "0x" + signature[66:130]
open_channel_body = {
'order_id': order_id, 'sender': order_data["wallet_address"],
'signature': order_data["signature"], 'r': r, 's': s, 'v': v,
'group_id': group_id, 'org_id': org_id, 'amount': amount, 'currency': currency,
'recipient': recipient, 'current_block_no': order_data["current_block_number"],
'amount_in_cogs': amount_in_cogs
}
channel_details = self.wallet_service.create_channel(open_channel_body=open_channel_body)
logger.info("channel_details: ", channel_details)
return channel_details
except Exception as e:
logger.error("Failed to create channel")
logger.error(repr(e))
raise ChannelCreationFailed("Failed to create channel", wallet_details=order_data)
elif order_type == OrderType.FUND_CHANNEL.value:
try:
fund_channel_body = {
'order_id': order_id,
'group_id': group_id,
'org_id': org_id,
'amount': amount,
'channel_id': channel_id,
'currency': currency,
'recipient': recipient,
'sender': sender,
'amount_in_cogs': amount_in_cogs
}
fund_channel_payload = {
"path": "/wallet/channel/deposit",
"body": json.dumps(fund_channel_body),
"httpMethod": "POST"
}
fund_channel_lambda_response = self.lambda_client.invoke(
FunctionName=WALLETS_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(fund_channel_payload)
)
fund_channel_response = json.loads(fund_channel_lambda_response.get("Payload").read())
if fund_channel_response["statusCode"] != 200:
raise Exception(f"Failed to add funds in channel for {fund_channel_body}")
fund_channel_response_body = json.loads(fund_channel_response["body"])
fund_channel_transaction_details = fund_channel_response_body["data"]
return fund_channel_transaction_details
except Exception as e:
logger.error("Failed to fund channel")
logger.error(repr(e))
raise FundChannelFailed()
else:
raise Exception("Order type is not valid.")
def get_order_details_by_username(self, username):
order_details_event = {
"path": f"/order",
"queryStringParameters": {"username": username},
"httpMethod": "GET"
}
logger.info(f"Requesting order details for username {username}")
order_details_response = self.boto_client.invoke_lambda(
lambda_function_arn=ORDER_DETAILS_BY_USERNAME_ARN,
invocation_type='RequestResponse',
payload=json.dumps(order_details_event)
)
if order_details_response["statusCode"] != 200:
raise Exception(f"Failed to fetch order details for username{username}")
org_id_name_mapping = self.get_organizations_from_contract()
order_details_response_body = json.loads(order_details_response["body"])
orders = order_details_response_body["orders"]
for order in orders:
order_id = order["order_id"]
order["wallet_type"] = "GENERAL"
if "org_id" in order["item_details"]:
org_id = order["item_details"]["org_id"]
if org_id in org_id_name_mapping:
order["item_details"]["organization_name"] = org_id_name_mapping[org_id]
transaction_details_event = {
"path": f"/wallet/channel/transactions",
"queryStringParameters": {"order_id": order_id},
"httpMethod": "GET"
}
transaction_details_lambda_response = self.lambda_client.invoke(
FunctionName=WALLETS_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(transaction_details_event)
)
transaction_details_response = json.loads(transaction_details_lambda_response.get('Payload').read())
if transaction_details_response["statusCode"] != 200:
raise Exception(f"Failed to fetch transaction details for username{order_id}")
transaction_details_response_body = json.loads(transaction_details_response["body"])
order["wallet_transactions"] = transaction_details_response_body["data"]["transactions"]
order_status = TransactionStatus.SUCCESS
for payment in order["payments"]:
if payment["payment_status"] != TransactionStatus.SUCCESS:
order_status = payment["payment_status"]
break
for wallet_transaction in order["wallet_transactions"]:
if wallet_transaction["status"] != TransactionStatus.SUCCESS:
order_status = wallet_transaction["status"]
break
order["order_status"] = order_status
return {"orders": orders}
def get_organizations_from_contract(self):
org_details_event = {
"path": f"/org",
"httpMethod": "GET"
}
org_details_response = self.boto_client.invoke_lambda(
lambda_function_arn=GET_ALL_ORG_API_ARN,
invocation_type='RequestResponse',
payload=json.dumps(org_details_event)
)
if org_details_response["statusCode"] != 200:
raise Exception("Failed to get org details")
org_details = json.loads(org_details_response["body"])["data"]
org_id_name_mapping = {}
for org in org_details:
org_id_name_mapping[org["org_id"]] = org["org_name"]
return org_id_name_mapping
def generate_signature_for_open_channel_for_third_party(self, recipient, group_id, amount_in_cogs, expiration,
message_nonce, sender_private_key, executor_wallet_address):
signature_for_open_channel_for_third_party_body = {
'recipient': recipient,
'group_id': group_id,
'amount_in_cogs': amount_in_cogs,
'expiration': expiration,
'message_nonce': message_nonce,
'signer_key': sender_private_key,
'executor_wallet_address': executor_wallet_address
}
signature_for_open_channel_for_third_party_payload = {
"path": "/signer/open-channel-for-third-party",
"body": json.dumps(signature_for_open_channel_for_third_party_body),
"httpMethod": "POST"
}
signature_for_open_channel_for_third_party_response = self.lambda_client.invoke(
FunctionName=SIGNER_SERVICE_ARN,
InvocationType='RequestResponse',
Payload=json.dumps(signature_for_open_channel_for_third_party_payload)
)
signature_response = json.loads(signature_for_open_channel_for_third_party_response.get("Payload").read())
if signature_response["statusCode"] != 200:
raise Exception(f"Failed to create signature for {signature_for_open_channel_for_third_party_body}")
signature_details = json.loads(signature_response["body"])
return signature_details["data"]
def cancel_order(self):
logger.info("Start of UpdateTransactionStatus::manage_update_canceled_order_in_txn_history")
list_of_order_id_for_expired_transaction = self.obj_transaction_history_dao.get_order_id_for_expired_transaction()
logger.info(f"List of order_id to be updated with ORDER CANCELED: {list_of_order_id_for_expired_transaction}")
update_transaction_status = self.obj_transaction_history_dao.update_transaction_status(
list_of_order_id=list_of_order_id_for_expired_transaction, status=OrderStatus.ORDER_CANCELED.value)
return update_transaction_status
def cancel_order_for_given_order_id(self, order_id):
logger.info("UpdateTransactionStatus::cancel_order_for_given_order_id: %s", order_id)
transaction_data_dict = self.obj_transaction_history_dao.get_transaction_details_for_given_order_id(
order_id=order_id)
if transaction_data_dict["status"] == OrderStatus.ORDER_CANCELED.value:
return f"Order with order_id {order_id} is already canceled."
elif transaction_data_dict["status"] in [OrderStatus.PAYMENT_INITIATED.value,
OrderStatus.PAYMENT_INITIATION_FAILED.value,
OrderStatus.PAYMENT_EXECUTION_FAILED]:
self.obj_transaction_history_dao.update_transaction_status(list_of_order_id=[order_id],
status=OrderStatus.ORDER_CANCELED.value)
return f"Order with order_id {order_id} is canceled successfully."
else:
return f"Unable to cancel order with order_id {order_id}"
def currency_to_token(self, amount, currency):
amount_in_cogs = self.calculate_amount_in_cogs(amount=decimal.Decimal(amount), currency=currency)
conversion_data = {"base": currency, "amount": amount, "amount_in_cogs": str(amount_in_cogs),
"amount_in_agi": str(self.utils.cogs_to_agi(cogs=amount_in_cogs)),
f"{currency}/cogs": str(USD_TO_COGS_CONVERSION_FACTOR), "agi/cogs": str(COGS_TO_AGI)}
logger.debug(f"currency_to_token::conversion_data {conversion_data}")
return conversion_data
class PaypalPayment(Payment):
def __init__(self, payment_id, amount, currency, payment_status, created_at, payment_details):
super().__init__(payment_id, amount, currency, payment_status, created_at, payment_details)
self.boto_utils = BotoUtils(region_name=REGION_NAME)
def initiate_payment(self, order_id, item_details):
try:
payee_client_api = paypalrestsdk.Api({
'mode': MODE,
'client_id': self.boto_utils.get_ssm_parameter(PAYPAL_CLIENT),
'client_secret': self.boto_utils.get_ssm_parameter(PAYPAL_SECRET)
})
except Exception as e:
logger.error("Failed to get ssm parameters")
raise e
paypal_payload = self.get_paypal_payload(order_id, item_details["org_id"], item_details["service_id"])
payment = paypalrestsdk.Payment(paypal_payload, api=payee_client_api)
if not payment.create():
logger.error(f"Paypal error:{payment.error}")
raise Exception("Payment failed to create")
logger.info(f"Paypal payment initiated with paypal_payment_id: {payment.id}")
approval_url = ""
for link in payment.links:
if link.rel == "approval_url":
approval_url = str(link.href)
if len(approval_url) == 0:
raise Exception("Payment link not found")
self._payment_details["payment_id"] = payment.id
response_payload = {
"payment": {
"id": payment.id,
"payment_url": approval_url
}
}
return response_payload
def execute_transaction(self, paid_payment_details):
try:
payee_client_api = paypalrestsdk.Api({
'mode': MODE,
'client_id': self.boto_utils.get_ssm_parameter(PAYPAL_CLIENT),
'client_secret': self.boto_utils.get_ssm_parameter(PAYPAL_SECRET)
})
except Exception as e:
logger.error("Failed to get ssm parameters")
raise e
paypal_payment_id = self._payment_details["payment_id"]
payer_id = paid_payment_details["payer_id"]
payment = paypalrestsdk.Payment.find(paypal_payment_id, api=payee_client_api)
if payment.execute({"payer_id": payer_id}):
logger.info(f"Paypal payment execution is success for paypal_payment_id:{paypal_payment_id}")
self._payment_status = PaymentStatus.SUCCESS
return True
elif self._payment_status == PaymentStatus.PENDING:
logger.info(f"Paypal payment execution is failed for paypal_payment_id:{paypal_payment_id}")
self._payment_status = PaymentStatus.FAILED
logger.error(payment.error)
return False
def get_paypal_payload(self, order_id, org_id, service_id):
paypal_payload = {
"intent": "sale",
"payer": {
"payment_method": PAYMENT_METHOD_PAYPAL
},
"redirect_urls": {
"return_url": PAYMENT_RETURN_URL.format(org_id, service_id, order_id, self._payment_id),
"cancel_url": PAYMENT_CANCEL_URL.format(org_id, service_id, order_id, self._payment_id)
},
"transactions": [
{
"item_list": {
"items": [
{
"name": "item",
"sku": "item",
"price": self._amount,
"currency": self._currency,
"quantity": 1
}
]
},
"amount": {
"total": self._amount,
"currency": self._currency
},
"description": ""
}
]
}
return paypal_payload
class User:
def __init__(self, obj_repo):
self.repo = obj_repo
self.obj_utils = Utils()
self.boto_client = BotoUtils(region_name=REGION_NAME)
def _set_user_data(self, user_data, origin):
""" Method to set user information. """
try:
claims = user_data['authorizer']['claims']
email_verified = claims['email_verified']
status = 0
if email_verified:
status = 1
else:
raise Exception("Email verification is pending.")
q_dta = [claims['email'], user_data['accountId'], origin, claims['nickname'], claims['email'], status,
status, user_data['requestId'], user_data['requestTimeEpoch'], dt.utcnow(), dt.utcnow()]
set_usr_dta = self.repo.execute(
"INSERT INTO user (username, account_id, origin, name, email, email_verified, status, request_id, "
"request_time_epoch, row_created, row_updated) "
"VALUES(%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)", q_dta)
if len(set_usr_dta) > 0:
return "success"
else:
return "User already exist"
except Exception as e:
print(repr(e))
raise e
def _fetch_private_key_from_ssm(self, address):
try:
store = self.boto_client.get_ssm_parameter(parameter=PATH_PREFIX + str(address))
return store['Parameter']['Value']
except Exception as e:
print(repr(e))
raise Exception("Error fetching value from parameter store.")
def user_signup(self, user_data, origin):
""" Method to assign pre-seeded wallet to user.
This is one time process.
"""
try:
username = user_data['authorizer']['claims']['email']
set_user_data = self._set_user_data(user_data, origin)
print(set_user_data)
return set_user_data
except Exception as e:
self.repo.rollback_transaction()
print(repr(e))
raise e
def get_user_profile(self, user_data):
"""
Method to fetch user profile data.
"""
try:
username = user_data['authorizer']['claims']['email']
result = self.repo.execute(
"SELECT * FROM user WHERE username = %s", [username])
self.obj_utils.clean(result)
return {"success": "success", "data": result}
except Exception as e:
print(repr(e))
raise e
def update_user_profile(self, email_alerts, is_terms_accepted, user_data):
"""
Method to update user profile data.
"""
try:
username = user_data['authorizer']['claims']['email']
result = self.repo.execute("UPDATE user SET email_alerts = %s, is_terms_accepted = %s WHERE username = %s",
[int(email_alerts is True), int(is_terms_accepted is True), username])
return {"success": "success", "data": []}
except Exception as e:
print(repr(e))
raise e
def validate_and_set_user_feedback(self, feedback_data, user_data):
"""
Method to validate and set user feedback data.
"""
schema = Schema([{'org_id': And(str),
'service_id': And(str),
'user_rating': And(str),
'comment': And(str)
}])
try:
feedback_data = schema.validate([feedback_data])
feedback_recorded = self._set_user_feedback(
feedback_data[0], user_data=user_data)
if feedback_recorded:
return []
return None
except Exception as err:
print("Invalid Input ", err)
return None
def get_user_feedback(self, user_data, org_id, service_id):
"""
Method to get user feedback data.
"""
try:
user_rating_dict = {}
username = user_data['authorizer']['claims']['email']
query_part = ""
query_part_values = []
if org_id is not None:
query_part = "AND org_id = %s "
query_part_values.append(org_id)
if service_id is not None:
query_part += "AND service_id = %s "
query_part_values.append(service_id)
rating_query = "SELECT * FROM user_service_vote WHERE username = %s " + query_part
rating = self.repo.execute(
rating_query, [username] + query_part_values)
self.obj_utils.clean(rating)
feedback_query = "SELECT * FROM user_service_feedback WHERE username = %s " + query_part
feedback = self.repo.execute(
feedback_query, [username] + query_part_values)
self.obj_utils.clean(feedback)
for record in feedback:
org_id = record['org_id']
service_id = record['service_id']
if org_id not in user_rating_dict.keys():
user_rating_dict[org_id] = {}
if service_id not in user_rating_dict.keys():
user_rating_dict[org_id][service_id] = {}
user_rating_dict[org_id][service_id]['comment'] = []
user_rating_dict[org_id][service_id]['comment'].append(
record['comment'])
for record in rating:
org_id = record['org_id']
service_id = record['service_id']
record.update({'comment': user_rating_dict.get(org_id, {})
.get(service_id, {})
.get("comment", [])})
return rating
except Exception as e:
print(repr(e))
raise e
def _set_user_feedback(self, feedback_data, user_data):
"""
Method to set user rating and feedback.
"""
try:
user_rating = str(feedback_data['user_rating'])
if float(user_rating) > 5.0 or float(user_rating) < 1.0:
raise Exception(
"Invalid Rating. Provided user rating should be between 1.0 and 5.0 .")
curr_dt = dt.utcnow()
username = user_data['authorizer']['claims']['email']
org_id = feedback_data['org_id']
service_id = feedback_data['service_id']
comment = feedback_data['comment']
self.repo.begin_transaction()
set_rating = "INSERT INTO user_service_vote (username, org_id, service_id, rating, row_updated, row_created) " \
"VALUES (%s, %s, %s, %s, %s, %s) " \
"ON DUPLICATE KEY UPDATE rating = %s, row_updated = %s"
set_rating_params = [username, org_id, service_id,
user_rating, curr_dt, curr_dt, user_rating, curr_dt]
self.repo.execute(set_rating, set_rating_params)
set_feedback = "INSERT INTO user_service_feedback (username, org_id, service_id, comment, row_updated, row_created)" \
"VALUES (%s, %s, %s, %s, %s, %s)"
set_feedback_params = [username, org_id,
service_id, comment, curr_dt, curr_dt]
self.repo.execute(set_feedback, set_feedback_params)
self._update_service_rating(org_id=org_id, service_id=service_id)
self.repo.commit_transaction()
return True
except Exception as e:
self.repo.rollback_transaction()
print(repr(e))
raise e
def _update_service_rating(self, org_id, service_id):
"""
Method updates service_rating and total_user_rated when user rating is changed for given service_id
and org_id.
"""
try:
update_service_metadata = self.repo.execute(
"UPDATE service_metadata A INNER JOIN (SELECT U.org_id, U.service_id, AVG(U.rating) AS service_rating, "
"count(*) AS total_users_rated FROM user_service_vote AS U WHERE U.rating IS NOT NULL GROUP BY "
"U.service_id, U.org_id ) AS B ON A.org_id=B.org_id AND A.service_id=B.service_id SET A.service_rating "
"= CONCAT('{\"rating\":', B.service_rating, ' , \"total_users_rated\":', B.total_users_rated, '}') "
"WHERE A.org_id = %s AND A.service_id = %s ", [org_id, service_id])
except Exception as e:
print(repr(e))
raise e