Created wallet and refund models, exceptions for refund and invoice, created methods for refund and wallet

Author: ppatidar2021

src/bitpay_sdk/client.py

@@ -5,12 +5,20 @@
 from .tokens import Tokens
 from .models.facade import Facade
 from .utils.rest_cli import RESTcli
+from .models.wallet.wallet import Wallet
+from .models.invoice.refund import Refund
 from .models.invoice.invoice import Invoice
+from .exceptions.bitpay_exception import BitPayException
+from .exceptions.wallet_query_exception import WalletQueryException
+from .exceptions.refund_query_exception import RefundQueryException
+from .exceptions.refund_update_exception import RefundUpdateException
 from .exceptions.invoice_query_exception import InvoiceQueryException
 from .exceptions.invoice_update_exception import InvoiceUpdateException
+from .exceptions.refund_creation_exception import RefundCreationException
+from .exceptions.refund_notification_exception import RefundNotificationException
+from .exceptions.refund_cancellation_exception import RefundCancellationException
 from .exceptions.invoice_cancellation_exception import InvoiceCancellationException
 from .exceptions.invoice_notification_exception import InvoiceNotificationException
-from .exceptions.bitpay_exception import BitPayException
 
 
 class Client:
@@ -234,42 +242,124 @@ def request_invoice_notifications(self, invoice_id: str) -> bool:
         except Exception as e:
             raise InvoiceNotificationException("failed to deserialize BitPay server response (Invoice) : %s" % str(e))
 
-    def create_refund(self, invoice_id, amount, currency, preview=False, immediate=False, buyer_pays_refund_fee=False):
+    def create_refund(self, invoice_id: str, amount: float, currency: str, preview: bool = False,
+                      immediate: bool = False, buyer_pays_refund_fee: bool = False) -> Refund:
         try:
             params = {"token": self.get_access_token(Facade.Merchant), "invoiceId": invoice_id, "amount": amount,
                       "currency": currency, "preview": preview, "immediate": immediate,
                       "buyerPaysRefundFee": buyer_pays_refund_fee}
 
             response_json = self.__restcli.post("refunds", params, True)
+        except BitPayException as e:
+            raise RefundCreationException("failed to serialize refund object :  %s" % e.get_message(),
+                                               e.get_api_code())
         except Exception as e:
-            print(e)
+            raise RefundCreationException("failed to serialize refund object : %s" % e)
 
-    def get_refund(self, refund_id):
+        try:
+            refund = Refund(**response_json)
+        except Exception as e:
+            raise RefundCreationException("failed to deserialize BitPay server response (Refund) : %s" % str(e))
+
+        return refund
+
+    def get_refund(self, refund_id: str) -> Refund:
         try:
             params = {"token": self.get_access_token(Facade.Merchant)}
             response_json = self.__restcli.get("refunds/%s" % refund_id, params)
+        except BitPayException as e:
+            raise RefundQueryException("failed to serialize refund object :  %s" % e.get_message(),
+                                               e.get_api_code())
         except Exception as e:
-            print(e)
+            raise RefundQueryException("failed to serialize refund object : %s" % e)
+        try:
+            refund = Refund(**response_json)
+        except Exception as e:
+            raise RefundQueryException("failed to deserialize BitPay server response (Refund) : %s" % str(e))
+
+        return refund
 
-    def get_refunds(self, invoice_id):
+    def get_refunds(self, invoice_id: str) -> [Refund]:
         try:
             params = {"token": self.get_access_token(Facade.Merchant), "invoiceId": invoice_id}
             response_json = self.__restcli.get("refunds", params)
+        except BitPayException as e:
+            raise RefundQueryException("failed to serialize refund object :  %s" % e.get_message(),
+                                               e.get_api_code())
         except Exception as e:
-            print(e)
+            raise RefundQueryException("failed to serialize refund object : %s" % e)
+
+        try:
+            refunds = Refund(**response_json)
+        except Exception as e:
+            raise RefundQueryException("failed to deserialize BitPay server response (Refund) : %s" % str(e))
 
-    def update_refund(self, refund_id, status):
-        params = {"token": self.get_access_token(Facade.Merchant)}
+        return refunds
 
-        if status:
-            params["status"] = status
+    def update_refund(self, refund_id: str, status: str) -> Refund:
         try:
+            params = {"token": self.get_access_token(Facade.Merchant), "status": status}
+
             response_json = self.__restcli.update("refunds/%s" % refund_id, params)
+        except BitPayException as e:
+            raise RefundUpdateException("failed to serialize refund object :  %s" % e.get_message(),
+                                               e.get_api_code())
         except Exception as e:
-            print(e)
+            raise RefundUpdateException("failed to serialize refund object : %s" % e)
+
+        try:
+            refund = Refund(**response_json)
+        except Exception as e:
+            raise RefundUpdateException("failed to deserialize BitPay server response (Refund) : %s" % str(e))
+
+        return refund
 
-    def cancel_refund(self, refund_id):
-        pass
+    def cancel_refund(self, refund_id: str) -> Refund:
+        try:
+            params = {"token": self.get_access_token(Facade.Merchant)}
+            response_json = self.__restcli.delete("refunds/%s" % refund_id, params)
+        except BitPayException as e:
+            raise RefundCancellationException("failed to serialize refund object :  %s" % e.get_message(),
+                                               e.get_api_code())
+        except Exception as e:
+            raise RefundCancellationException("failed to serialize refund object : %s" % e)
+
+        try:
+            refund = Refund(**response_json)
+        except Exception as e:
+            raise RefundCancellationException("failed to deserialize BitPay server response (Refund) : %s" % str(e))
+
+        return refund
+
+    def request_refund_notification(self, refund_id: str) -> bool:
+        try:
+            params = {"token": self.get_access_token(Facade.Merchant)}
+            response_json = self.__restcli.post("refunds/%s" % refund_id + "/notifications", params, True)
+        except BitPayException as e:
+            raise RefundNotificationException("failed to serialize refund object :  %s" % e.get_message(),
+                                               e.get_api_code())
+        except Exception as e:
+            raise RefundNotificationException("failed to serialize refund object : %s" % e)
+
+        try:
+            refund = Refund(**response_json)
+        except Exception as e:
+            raise RefundNotificationException("failed to deserialize BitPay server response (Refund) : %s" % str(e))
+
+        return refund
+
+    def get_supported_wallets(self) -> [Wallet]:
+        try:
+            response_json = self.__restcli.get("supportedWallets/", None)
+        except BitPayException as e:
+            raise WalletQueryException("failed to serialize wallet object :  %s" % e.get_message(),
+                                               e.get_api_code())
+        except Exception as e:
+            raise WalletQueryException("failed to serialize wallet object : %s" % e)
+
+        try:
+            wallet = Wallet(**response_json)
+        except Exception as e:
+            raise WalletQueryException("failed to deserialize BitPay server response (Wallet) : %s" % str(e))
 
-    def request_refund_notification(self, refund_id):
-        pass
+        return wallet

src/bitpay_sdk/exceptions/refund_cancellation_exception.py

@@ -0,0 +1,15 @@
+from src.bitpay_sdk.exceptions.refund_exception import RefundException
+
+
+class RefundCancellationException(RefundException):
+    __bitpay_message = "Failed to cancel refund object"
+    __bitpay_code = "BITPAY-REFUND-CANCEL"
+    __api_code = ""
+
+    def __init__(self, message, code=165, api_code="000000"):
+        message = self.__bitpay_code + ": " + self.__bitpay_message + ":" + message
+        self.__api_code = api_code
+        super.__init__(message, code)
+
+    def get_api_code(self):
+        return self.__api_code

src/bitpay_sdk/exceptions/refund_creation_exception.py

@@ -0,0 +1,15 @@
+from src.bitpay_sdk.exceptions.refund_exception import RefundException
+
+
+class RefundCreationException(RefundException):
+    __bitpay_message = "Failed to create refund"
+    __bitpay_code = "BITPAY-REFUND-CREATE"
+    __api_code = ""
+
+    def __init__(self, message, code=162, api_code="000000"):
+        message = self.__bitpay_code + ": " + self.__bitpay_message + ":" + message
+        self.__api_code = api_code
+        super.__init__(message, code)
+
+    def get_api_code(self):
+        return self.__api_code

src/bitpay_sdk/exceptions/refund_exception.py

@@ -0,0 +1,15 @@
+from .bitpay_exception import BitPayException
+
+
+class RefundException(BitPayException):
+    __bitpay_message = "An unexpected error occurred while trying to manage the refund"
+    __bitpay_code = "BITPAY-REFUND-GENERIC"
+    __api_code = ""
+
+    def __init__(self, message="", code=161, api_code="000000"):
+        message = self.__bitpay_code + ": " + self.__bitpay_message + ":" + message
+        self.__api_code = api_code
+        super().__init__(message, code)
+
+    def get_api_code(self):
+        return self.__api_code

src/bitpay_sdk/exceptions/refund_notification_exception.py

@@ -0,0 +1,15 @@
+from src.bitpay_sdk.exceptions.refund_exception import RefundException
+
+
+class RefundNotificationException(RefundException):
+    __bitpay_message = "Failed to send refund notification"
+    __bitpay_code = "BITPAY-REFUND-NOTIFICATION"
+    __api_code = ""
+
+    def __init__(self, message, code=166, api_code="000000"):
+        message = self.__bitpay_code + ": " + self.__bitpay_message + ":" + message
+        self.__api_code = api_code
+        super.__init__(message, code)
+
+    def get_api_code(self):
+        return self.__api_code

src/bitpay_sdk/exceptions/refund_query_exception.py

@@ -0,0 +1,15 @@
+from src.bitpay_sdk.exceptions.refund_exception import RefundException
+
+
+class RefundQueryException(RefundException):
+    __bitpay_message = "Failed to retrieve refund"
+    __bitpay_code = "BITPAY-REFUND-GET"
+    __api_code = ""
+
+    def __init__(self, message, code=163, api_code="000000"):
+        message = self.__bitpay_code + ": " + self.__bitpay_message + ":" + message
+        self.__api_code = api_code
+        super.__init__(message, code)
+
+    def get_api_code(self):
+        return self.__api_code

src/bitpay_sdk/exceptions/refund_update_exception.py

@@ -0,0 +1,15 @@
+from src.bitpay_sdk.exceptions.refund_exception import RefundException
+
+
+class RefundUpdateException(RefundException):
+    __bitpay_message = "Failed to update refund"
+    __bitpay_code = "BITPAY-REFUND-UPDATE"
+    __api_code = ""
+
+    def __init__(self, message, code=164, api_code="000000"):
+        message = self.__bitpay_code + ": " + self.__bitpay_message + ":" + message
+        self.__api_code = api_code
+        super.__init__(message, code)
+
+    def get_api_code(self):
+        return self.__api_code

src/bitpay_sdk/exceptions/wallet_exception.py

@@ -0,0 +1,15 @@
+from .bitpay_exception import BitPayException
+
+
+class WalletException(BitPayException):
+    __bitpay_message = "An unexpected error occurred while trying to manage the wallet"
+    __bitpay_code = "BITPAY-WALLET-GENERIC"
+    __api_code = ""
+
+    def __init__(self, message="", code=181, api_code="000000"):
+        message = self.__bitpay_code + ": " + self.__bitpay_message + ":" + message
+        self.__api_code = api_code
+        super().__init__(message, code)
+
+    def get_api_code(self):
+        return self.__api_code

src/bitpay_sdk/exceptions/wallet_query_exception.py

@@ -0,0 +1,15 @@
+from src.bitpay_sdk.exceptions.wallet_exception import WalletException
+
+
+class WalletQueryException(WalletException):
+    __bitpay_message = "Failed to retrieve supported wallets"
+    __bitpay_code = "BITPAY-WALLET-GET"
+    __api_code = ""
+
+    def __init__(self, message, code=183, api_code="000000"):
+        message = self.__bitpay_code + ": " + self.__bitpay_message + ":" + message
+        self.__api_code = api_code
+        super.__init__(message, code)
+
+    def get_api_code(self):
+        return self.__api_code