feat: added invoice_return_url on tokens

Author: processout-machine

processout/__init__.py

@@ -25,6 +25,7 @@
 from processout.invoicerisk import InvoiceRisk
 from processout.invoicedevice import InvoiceDevice
 from processout.invoiceshipping import InvoiceShipping
+from processout.invoicebilling import InvoiceBilling
 from processout.invoicedetail import InvoiceDetail
 from processout.customeraction import CustomerAction
 from processout.dunningaction import DunningAction

processout/client.py

@@ -171,6 +171,12 @@ def new_invoice_shipping(self, prefill=None):
         prefill -- Data used to prefill the object (optional)"""
         return processout.InvoiceShipping(self, prefill)
 
+    def new_invoice_billing(self, prefill=None):
+        """Create a new InvoiceBilling instance
+        Keyword argument:
+        prefill -- Data used to prefill the object (optional)"""
+        return processout.InvoiceBilling(self, prefill)
+
     def new_invoice_detail(self, prefill=None):
         """Create a new InvoiceDetail instance
         Keyword argument:

processout/customeraction.py

@@ -18,6 +18,7 @@ def __init__(self, client, prefill=None):
 
         self._type = None
         self._value = None
+        self._metadata = None
         if prefill is not None:
             self.fill_with_data(prefill)
 
@@ -47,6 +48,19 @@ def value(self, val):
         self._value = val
         return self
 
+    @property
+    def metadata(self):
+        """Get metadata"""
+        return self._metadata
+
+    @metadata.setter
+    def metadata(self, val):
+        """Set metadata
+        Keyword argument:
+        val -- New metadata value"""
+        self._metadata = val
+        return self
+
     def fill_with_data(self, data):
         """Fill the current object with the new values pulled from data
         Keyword argument:
@@ -55,11 +69,14 @@ def fill_with_data(self, data):
             self.type = data["type"]
         if "value" in data.keys():
             self.value = data["value"]
+        if "metadata" in data.keys():
+            self.metadata = data["metadata"]
 
         return self
 
     def to_json(self):
         return {
             "type": self.type,
             "value": self.value,
+            "metadata": self.metadata,
         }

processout/gatewayconfiguration.py

@@ -27,6 +27,7 @@ def __init__(self, client, prefill=None):
         self._public_keys = None
         self._created_at = None
         self._enabled_at = None
+        self._processing_region = None
         if prefill is not None:
             self.fill_with_data(prefill)
 
@@ -191,6 +192,19 @@ def enabled_at(self, val):
         self._enabled_at = val
         return self
 
+    @property
+    def processing_region(self):
+        """Get processing_region"""
+        return self._processing_region
+
+    @processing_region.setter
+    def processing_region(self, val):
+        """Set processing_region
+        Keyword argument:
+        val -- New processing_region value"""
+        self._processing_region = val
+        return self
+
     def fill_with_data(self, data):
         """Fill the current object with the new values pulled from data
         Keyword argument:
@@ -217,6 +231,8 @@ def fill_with_data(self, data):
             self.created_at = data["created_at"]
         if "enabled_at" in data.keys():
             self.enabled_at = data["enabled_at"]
+        if "processing_region" in data.keys():
+            self.processing_region = data["processing_region"]
 
         return self
 
@@ -233,6 +249,7 @@ def to_json(self):
             "public_keys": self.public_keys,
             "created_at": self.created_at,
             "enabled_at": self.enabled_at,
+            "processing_region": self.processing_region,
         }
 
     def all(self, options={}):
@@ -300,6 +317,7 @@ def save(self, options={}):
             'name': self.name,
             'enabled': self.enabled,
             'default_currency': self.default_currency,
+            'processing_region': self.processing_region,
             'settings': options.get("settings"),
             'sub_accounts_enabled': options.get("sub_accounts_enabled")
         }
@@ -349,6 +367,7 @@ def create(self, gateway_name, options={}):
             'name': self.name,
             'enabled': self.enabled,
             'default_currency': self.default_currency,
+            'processing_region': self.processing_region,
             'settings': options.get("settings"),
             'sub_accounts_enabled': options.get("sub_accounts_enabled")
         }

processout/invoice.py

@@ -58,6 +58,7 @@ def __init__(self, client, prefill=None):
         self._payment_type = None
         self._initiation_type = None
         self._payment_intent = None
+        self._billing = None
         if prefill is not None:
             self.fill_with_data(prefill)
 
@@ -709,6 +710,28 @@ def payment_intent(self, val):
         self._payment_intent = val
         return self
 
+    @property
+    def billing(self):
+        """Get billing"""
+        return self._billing
+
+    @billing.setter
+    def billing(self, val):
+        """Set billing
+        Keyword argument:
+        val -- New billing value"""
+        if val is None:
+            self._billing = val
+            return self
+
+        if isinstance(val, dict):
+            obj = processout.InvoiceBilling(self._client)
+            obj.fill_with_data(val)
+            self._billing = obj
+        else:
+            self._billing = val
+        return self
+
     def fill_with_data(self, data):
         """Fill the current object with the new values pulled from data
         Keyword argument:
@@ -797,6 +820,8 @@ def fill_with_data(self, data):
             self.initiation_type = data["initiation_type"]
         if "payment_intent" in data.keys():
             self.payment_intent = data["payment_intent"]
+        if "billing" in data.keys():
+            self.billing = data["billing"]
 
         return self
 
@@ -844,6 +869,7 @@ def to_json(self):
             "payment_type": self.payment_type,
             "initiation_type": self.initiation_type,
             "payment_intent": self.payment_intent,
+            "billing": self.billing,
         }
 
     def increment_authorization(self, amount, options={}):
@@ -889,6 +915,7 @@ def authorize(self, source, options={}):
             'allow_fallback_to_sale': options.get("allow_fallback_to_sale"),
             'auto_capture_at': options.get("auto_capture_at"),
             'metadata': options.get("metadata"),
+            'override_mac_blocking': options.get("override_mac_blocking"),
             'source': source}
 
         response = Response(request.post(path, data, options))
@@ -921,6 +948,7 @@ def capture(self, source, options={}):
             'enable_three_d_s_2': options.get("enable_three_d_s_2"),
             'metadata': options.get("metadata"),
             'capture_statement_descriptor': options.get("capture_statement_descriptor"),
+            'override_mac_blocking': options.get("override_mac_blocking"),
             'source': source}
 
         response = Response(request.post(path, data, options))
@@ -1113,7 +1141,8 @@ def create(self, options={}):
             'require_backend_capture': self.require_backend_capture,
             'external_fraud_tools': self.external_fraud_tools,
             'tax': self.tax,
-            'payment_type': self.payment_type
+            'payment_type': self.payment_type,
+            'billing': self.billing
         }
 
         response = Response(request.post(path, data, options))

processout/invoicebilling.py

@@ -0,0 +1,133 @@
+try:
+    from urllib.parse import quote_plus
+except ImportError:
+    from urllib import quote_plus
+
+import processout
+import json
+
+from processout.networking.request import Request
+from processout.networking.response import Response
+
+# The content of this file was automatically generated
+
+
+class InvoiceBilling(object):
+    def __init__(self, client, prefill=None):
+        self._client = client
+
+        self._address1 = None
+        self._address2 = None
+        self._city = None
+        self._state = None
+        self._country_code = None
+        self._zip = None
+        if prefill is not None:
+            self.fill_with_data(prefill)
+
+    @property
+    def address1(self):
+        """Get address1"""
+        return self._address1
+
+    @address1.setter
+    def address1(self, val):
+        """Set address1
+        Keyword argument:
+        val -- New address1 value"""
+        self._address1 = val
+        return self
+
+    @property
+    def address2(self):
+        """Get address2"""
+        return self._address2
+
+    @address2.setter
+    def address2(self, val):
+        """Set address2
+        Keyword argument:
+        val -- New address2 value"""
+        self._address2 = val
+        return self
+
+    @property
+    def city(self):
+        """Get city"""
+        return self._city
+
+    @city.setter
+    def city(self, val):
+        """Set city
+        Keyword argument:
+        val -- New city value"""
+        self._city = val
+        return self
+
+    @property
+    def state(self):
+        """Get state"""
+        return self._state
+
+    @state.setter
+    def state(self, val):
+        """Set state
+        Keyword argument:
+        val -- New state value"""
+        self._state = val
+        return self
+
+    @property
+    def country_code(self):
+        """Get country_code"""
+        return self._country_code
+
+    @country_code.setter
+    def country_code(self, val):
+        """Set country_code
+        Keyword argument:
+        val -- New country_code value"""
+        self._country_code = val
+        return self
+
+    @property
+    def zip(self):
+        """Get zip"""
+        return self._zip
+
+    @zip.setter
+    def zip(self, val):
+        """Set zip
+        Keyword argument:
+        val -- New zip value"""
+        self._zip = val
+        return self
+
+    def fill_with_data(self, data):
+        """Fill the current object with the new values pulled from data
+        Keyword argument:
+        data -- The data from which to pull the new values"""
+        if "address1" in data.keys():
+            self.address1 = data["address1"]
+        if "address2" in data.keys():
+            self.address2 = data["address2"]
+        if "city" in data.keys():
+            self.city = data["city"]
+        if "state" in data.keys():
+            self.state = data["state"]
+        if "country_code" in data.keys():
+            self.country_code = data["country_code"]
+        if "zip" in data.keys():
+            self.zip = data["zip"]
+
+        return self
+
+    def to_json(self):
+        return {
+            "address1": self.address1,
+            "address2": self.address2,
+            "city": self.city,
+            "state": self.state,
+            "country_code": self.country_code,
+            "zip": self.zip,
+        }

processout/invoiceexternalfraudtools.py

@@ -17,6 +17,7 @@ def __init__(self, client, prefill=None):
         self._client = client
 
         self._forter = None
+        self._signifyd = None
         if prefill is not None:
             self.fill_with_data(prefill)
 
@@ -33,16 +34,32 @@ def forter(self, val):
         self._forter = val
         return self
 
+    @property
+    def signifyd(self):
+        """Get signifyd"""
+        return self._signifyd
+
+    @signifyd.setter
+    def signifyd(self, val):
+        """Set signifyd
+        Keyword argument:
+        val -- New signifyd value"""
+        self._signifyd = val
+        return self
+
     def fill_with_data(self, data):
         """Fill the current object with the new values pulled from data
         Keyword argument:
         data -- The data from which to pull the new values"""
         if "forter" in data.keys():
             self.forter = data["forter"]
+        if "signifyd" in data.keys():
+            self.signifyd = data["signifyd"]
 
         return self
 
     def to_json(self):
         return {
             "forter": self.forter,
+            "signifyd": self.signifyd,
         }