BitPay setup and invoice

Author: ppatidar2021

setup/bitpay_setup.py

@@ -0,0 +1,112 @@
+import os
+import sys
+import json
+import requests
+
+# TODO: Need to remove below 2 lines
+root_dir = os.path.dirname(os.path.abspath(__file__))
+sys.path.append(os.path.dirname(root_dir))
+
+from src.bitpay_sdk.utils.key_utils import *
+from src.bitpay_sdk.exceptions.bitpay_exception import BitPayException
+
+is_prod = False  # Set to true if the environment for which the configuration file will be generated is Production.
+# Will be set to Test otherwise
+
+private_key_name = 'private_key.pem'  # Add here the name for your Private key
+generate_merchant_token = True  # Set to true to generate a token for the Merchant facade
+generate_payout_token = True  # Set to true to generate a token for the Payout facade
+your_master_password = 'YourMasterPassword'  # Will be used to encrypt your PrivateKey
+proxy = None
+base_url = 'https://bitpay.com' if is_prod else 'https://test.bitpay.com'
+env = 'Prod' if is_prod else 'Test'
+merchant_token = None
+payout_token = None
+
+root_path = os.path.abspath(os.curdir)
+
+try:
+    private_key = generate_pem()
+    with open(os.path.join(root_path, private_key_name), "wb") as f:
+        f.write(private_key.encode())
+except BitPayException as e:
+    print(e)
+
+# Generate the public key from the private key every time (no need to store the public key).
+try:
+    public_key = get_compressed_public_key_from_pem(private_key)
+except BitPayException as e:
+    print(e)
+
+try:
+    sin = get_sin_from_pem(private_key)
+except BitPayException as e:
+    print(e)
+
+try:
+    if generate_merchant_token:
+        facade = 'merchant'
+        payload = {'id': sin, 'facade': facade}
+
+        url = base_url + "/tokens"
+        headers = {"content-type": "application/json", "X-accept-version": "2.0.0"}
+        response = requests.post(url, verify=True, data=json.dumps(payload), headers=headers)
+
+        if response.ok:
+            merchant_token = response.json()['data'][0]['token']
+            print("Merchant Token: ", response.json()['data'][0]['token'])
+            print("Merchant Token Pairing Code: ", response.json()['data'][0]['pairingCode'])
+
+    if generate_payout_token:
+        facade = 'payout'
+        payload = {'id': sin, 'facade': facade}
+
+        url = base_url + "/tokens"
+        headers = {"content-type": "application/json", "X-accept-version": "2.0.0"}
+        response = requests.post(url, verify=True, data=json.dumps(payload), headers=headers)
+
+        if response.ok:
+            payout_token = response.json()['data'][0]['token']
+            print("Payout Token: ", response.json()['data'][0]['token'])
+            print("Payout Token Pairing Code: ", response.json()['data'][0]['pairingCode'])
+
+except BitPayException as e:
+    print(e)
+
+print("\r\nPlease, copy the above pairing code/s and approve on your BitPay Account at the following link:\r\n")
+print(f"{base_url}/dashboard/merchant/api-tokens\r\n")
+print("\r\nOnce you have this Pairing Code/s approved you can move the generated files to a secure location and start "
+      "using the Client.\r\n")
+
+# Generate config file
+config = {
+    "BitPayConfiguration": {
+        "Environment": env,
+        "EnvConfig": {
+            "Test": {
+                "PrivateKeyPath": None if is_prod else os.path.abspath("private_key.pem"),
+                "PrivateKeySecret": None if is_prod else your_master_password,
+                "ApiTokens": {
+                    "merchant": None if is_prod else merchant_token,
+                    "payout": None if is_prod else payout_token
+                },
+                "proxy": proxy
+            },
+            "Prod": {
+                "PrivateKeyPath": os.path.abspath("private.pem") if is_prod else None,
+                "PrivateKeySecret": your_master_password if is_prod else None,
+                "ApiTokens": {
+                    "merchant": merchant_token if is_prod else None,
+                    "payout": payout_token if is_prod else None
+                },
+                "proxy": proxy
+            }
+        }
+    }
+}
+
+try:
+    with open(os.path.abspath("bitpay.config.json"), 'w') as outfile:
+        json.dump(config, outfile)
+except BitPayException as e:
+    print(e)

src/__init__.py

@@ -0,0 +1,149 @@
+import os
+import json
+from .config import Config
+from .tokens import Tokens
+from .models.facade import Facade
+from .utils.rest_cli import RESTcli
+from .models.invoice.invoice import Invoice
+from .exceptions.bitpay_exception import BitPayException
+
+
+class Client:
+    __configuration = ""
+    __env = ""
+    __eckey = ""
+    __token_cache = ""
+    __restcli = None
+
+    def __init__(self, config_file_path):
+        self.build_config_from_file(config_file_path)
+        self.init_keys()
+        self.init()
+
+    def build_config_from_file(self, config_file_path):
+        self.__configuration = Config()
+
+        if os.path.exists(config_file_path):
+
+            try:
+                read_file = open(config_file_path, 'r')
+                content = read_file.read()
+                json_data = json.loads(content)
+                self.__configuration.set_environment(json_data['BitPayConfiguration']['Environment'])
+                self.__env = self.__configuration.get_environment()
+                tokens = json_data["BitPayConfiguration"]["EnvConfig"][self.__env]["ApiTokens"]
+                private_key_path = json_data["BitPayConfiguration"]["EnvConfig"][self.__env]["PrivateKeyPath"]
+                private_key_secret = json_data["BitPayConfiguration"]["EnvConfig"][self.__env]["PrivateKeySecret"]
+                proxy = json_data["BitPayConfiguration"]["EnvConfig"][self.__env]["proxy"]
+
+                env_config = {self.__env: {
+                    "PrivateKeyPath": private_key_path,
+                    "PrivateKeySecret": private_key_secret,
+                    "ApiTokens": tokens,
+                    "Proxy": proxy
+                }}
+                self.__configuration.set_envconfig(env_config)
+
+            except BitPayException as e:
+                print(e)
+
+        else:
+            raise BitPayException("Configuration file not found")
+
+    def init_keys(self):
+        private_key_path = self.__configuration.get_envconfig()[self.__env]["PrivateKeyPath"]
+        try:
+            if not self.__eckey:
+                with open(private_key_path) as f:
+                    self.__eckey = f.read()
+
+        except BitPayException as e:
+            raise BitPayException("failed to build configuration : ")
+
+    def init(self):
+        try:
+            proxy = self.__configuration.get_envconfig()[self.__env]["Proxy"]
+            self.__restcli = RESTcli(self.__env, self.__eckey, proxy)
+            self.load_access_tokens()
+            # TODO :load currencies
+        except BitPayException as e:
+            print(e)
+
+    def load_access_tokens(self):
+        try:
+            self.clear_access_token_cache()
+            self.__token_cache = self.__configuration.get_envconfig()[self.__env]["ApiTokens"]
+        except BitPayException as e:
+            print(e)
+
+    def clear_access_token_cache(self):
+        self.__token_cache = Tokens()
+
+    def create_invoice(self, invoice: Invoice, facade, sign_request=True):
+        try:
+            invoice.set_token(self.get_access_token(facade))
+            print(invoice)
+            invoice_json = invoice.to_json()
+
+            response = self.__restcli.post("invoices", invoice_json, sign_request)
+            print(response)
+
+        except BitPayException as e:
+            print(e)
+
+    def get_invoice(self, invoice_id, facade, sign_request=True):
+        try:
+            params = {"token": self.get_access_token(facade)}
+            response_json = self.__restcli.get("invoices/%s" % invoice_id, params, sign_request)
+        except BitPayException as e:
+            print(e)
+
+    def get_invoices(self, date_start, date_end, status, order_id, limit, offset):
+        try:
+            params = {"token": self.get_access_token(Facade.Merchant), "dateStart": date_start, "date_end": date_end}
+            response_json = self.__restcli.get("invoices/", parameters=params)
+        except BitPayException as e:
+            print(e)
+
+    def update_invoice(self, invoice_id, buyer_sms, sms_code, buyer_email):
+        try:
+            params = {'token': self.get_access_token(Facade.Merchant)}
+
+            if buyer_sms & sms_code:
+                pass
+
+            if buyer_sms is not None:
+                params['buyer_sms'] = buyer_sms
+
+            if sms_code is not None:
+                params['sms_code'] = sms_code
+
+            if buyer_email is not None:
+                params['buyer_email'] = buyer_email
+
+            response_json = self.__restcli.update("invoices/%s" % invoice_id, json.dumps(params))
+
+        except BitPayException as e:
+            print(e)
+
+    def cancel_invoice(self, invoice_id):
+        try:
+            params = {'token': self.get_access_token(Facade.Merchant)}
+            response_json = self.__restcli.delete("invoices/%s" % invoice_id, params)
+        except BitPayException as e:
+            print(e)
+
+    def get_invoice_webhook(self, invoice_id):
+        try:
+            self.get_invoice(invoice_id)
+            params = {}
+            # Conditions missing look from node
+            response_json = self.__restcli.post("invoices/%s" % invoice_id + "/notifications", params)
+        except BitPayException as e:
+            print(e)
+
+    def get_access_token(self, key: str):
+        try:
+            return self.__token_cache[key]
+        except BitPayException as e:
+            print(e)

src/bitpay_sdk/client.py

@@ -0,0 +1,18 @@
+class Config:
+    __environment = ""
+    __envconfig = ""
+
+    def __init__(self):
+        pass
+
+    def get_environment(self):
+        return self.__environment
+
+    def set_environment(self, environment):
+        self.__environment = environment
+
+    def get_envconfig(self):
+        return self.__envconfig
+
+    def set_envconfig(self, envconfig):
+        self.__envconfig = envconfig

src/bitpay_sdk/config.py

@@ -0,0 +1,24 @@
+class BitPayException(Exception):
+    __bitpay_message = "Unexpected Bitpay exception."
+    __bitpay_code = "BITPAY-GENERIC";
+    __apicode = ""
+
+    """
+        Construct the BitPayException.
+        
+        message (string) message [optional] The Exception message to throw.
+        code (int)    $code    [optional] The Exception code to throw.
+        @param string $apiCode [optional] The API Exception code to throw.
+    """
+
+    def __init__(self, message="", code=100, apicode="000000"):
+        if not message:
+            message = self.__bitpay_code + ": " + self.__bitpaymessage + ":" + message
+        self.__apicode = apicode
+        super().__init__(message)
+
+    """
+        @return string Error code provided by the BitPay REST API
+    """
+    def get_apicode(self):
+        return self.__apicode

src/bitpay_sdk/exceptions/bitpay_exception.py

@@ -0,0 +1,27 @@
+from bitpay_exception import BitPayException
+
+
+class InvoiceException(BitPayException):
+    __bitpay_message = "An unexpected error occurred while trying to manage the invoice"
+    __bitpay_code = "BITPAY-INVOICE-GENERIC"
+    __apicode = ""
+
+    '''
+    Construct the InvoiceException.
+    @param string $message [optional] The Exception message to throw.
+    @param int    $code    [optional] The Exception code to throw.
+    @param string $apicode [optional] The API Exception code to throw.
+    '''
+
+    def __init__(self, message="", code=100, apicode="000000"):
+        if not message:
+            message = self.__bitpay_code + ": " + self.__bitpay_message + ":" + message
+        self.__apicode = apicode
+        super().__init__(message)
+
+    """
+        @return string Error code provided by the BitPay REST API
+    """
+
+    def get_apicode(self):
+        return self.__apicode

src/bitpay_sdk/exceptions/invoice_exception.py

@@ -0,0 +1,3 @@
+class Facade:
+    Merchant = "merchant"
+    Payout = "payout"