python-terminusgps 1.9.5__py3-none-any.whl → 1.9.7__py3-none-any.whl

{python_terminusgps-1.9.5.dist-info → python_terminusgps-1.9.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-terminusgps
-Version: 1.9.5
+Version: 1.9.7
 Summary: Provides abstractions/utilities for working with Wialon API, Authorize.NET API, AWS API, and more.
 Project-URL: Documentation, https://app.terminusgps.com/docs/apps/python-terminusgps/index.html
 Project-URL: Repository, https://github.com/terminusgps/python-terminusgps

{python_terminusgps-1.9.5.dist-info → python_terminusgps-1.9.7.dist-info}/RECORD

@@ -1,11 +1,12 @@
 terminusgps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-terminusgps/settings.py,sha256=fxU6VuJVJaB_tHcIksH-3XPrFQHRD57nW7_9vMsZ6Ag,394
+terminusgps/settings.py,sha256=Mdeuo6ghfW28QVrBqe5mwwX2_Lk79fJ5kLfR9LV7zZM,314
 terminusgps/authorizenet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-terminusgps/authorizenet/auth.py,sha256=yznomWGTRbFiTDiugsRw1HqxJAV4aJKZFN3Bzdt_V8E,1119
-terminusgps/authorizenet/profiles/addresses.py,sha256=ir3GPdsSQtezQnM6IgavHj6Ii8uhOWGswIp_8KiN5OE,3377
-terminusgps/authorizenet/profiles/base.py,sha256=LIPDK78HqzYanoZF_gtbmLBEB_YF_MM7CNWvharPrMk,1974
-terminusgps/authorizenet/profiles/customers.py,sha256=vAD-bxUcNvAoIEQDdnu3QESiHPAjEV1g1i5l0tY5lVk,4536
-terminusgps/authorizenet/profiles/payments.py,sha256=En45JWqozaHn_1UHIf4G6V3nJvSHFaPit7ByV37kObo,5451
+terminusgps/authorizenet/auth.py,sha256=kWsqRT9OVEAQuNxDzQNzY1x2SqmvJr-HAbLwgkILntk,997
+terminusgps/authorizenet/profiles/__init__.py,sha256=QKjMKcXpCSCEhv6LBCz0yGP8t0VxAyKyYRS4_HLYnxQ,114
+terminusgps/authorizenet/profiles/addresses.py,sha256=ffAi3LcEOB3Xsr9f4N_PfjSZcN3I9dTKNamoAmnLpo4,3838
+terminusgps/authorizenet/profiles/base.py,sha256=Uk_VwtEVOomyV92ljVn7vcRn8BfwWHu80Jnct0NNlmw,2491
+terminusgps/authorizenet/profiles/customers.py,sha256=iEuNFP6PHuGdFQftgxxKpQFYaGw8IWLjsOaugvEOA-g,4513
+terminusgps/authorizenet/profiles/payments.py,sha256=qOWp-gO6qBCADP98WjoNCHm-jtq7DY5-moiPsOnT5yI,5263
 terminusgps/aws/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 terminusgps/aws/secrets.py,sha256=kgRA77rs0mD4berWRLkPtJLOe4Grf--o5f8NzwQqXCk,360
 terminusgps/wialon/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -22,7 +23,7 @@ terminusgps/wialon/items/route.py,sha256=qOHPN_rejwiGqvwWzlwmUIAIyc3lKavCalf8ki6
 terminusgps/wialon/items/unit.py,sha256=wzcLa0adMTKX6rtO4Vz6ntaxgY50rLk2KK_VBXlW_lQ,4680
 terminusgps/wialon/items/unit_group.py,sha256=1yc7ldPIgGbtiTj0djRDWmt6Q9K_VT9sxOaioasbbLY,5212
 terminusgps/wialon/items/user.py,sha256=bkcMw_YiocaMuhP_pBfB7apjAZwnsOzGScnGkn8Ybbw,6107
-python_terminusgps-1.9.5.dist-info/METADATA,sha256=Bcxr4BtJFA4R5rFR0289gCbAQFmM4V6SmkCXJCK19wo,882
-python_terminusgps-1.9.5.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_terminusgps-1.9.5.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-python_terminusgps-1.9.5.dist-info/RECORD,,
+python_terminusgps-1.9.7.dist-info/METADATA,sha256=AM9Wj1ho_7YrRdExekgsaiPG6zL8rrYRQfago0bpc6Q,882
+python_terminusgps-1.9.7.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_terminusgps-1.9.7.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+python_terminusgps-1.9.7.dist-info/RECORD,,

terminusgps/authorizenet/auth.py

@@ -1,23 +1,17 @@
 from authorizenet.apicontractsv1 import merchantAuthenticationType
 from authorizenet.constants import constants
 
-from django.conf import ImproperlyConfigured, settings
+from django.conf import settings
+from django.core.exceptions import ImproperlyConfigured
 
+if not hasattr(settings, "DEBUG"):
+    raise ImproperlyConfigured("'DEBUG' setting is required.")
+if not hasattr(settings, "MERCHANT_AUTH_LOGIN_ID"):
+    raise ImproperlyConfigured("'MERCHANT_AUTH_LOGIN_ID' setting is required.")
+if not hasattr(settings, "MERCHANT_AUTH_TRANSACTION_KEY"):
+    raise ImproperlyConfigured("'MERCHANT_AUTH_TRANSACTION_KEY' setting is required.")
 
-def settings_required(settings_list: list[str]):
-    def decorator(func):
-        def wrapped(*args, **kwargs):
-            for setting_name in settings_list:
-                if not hasattr(settings, setting_name):
-                    raise ImproperlyConfigured(f"'{setting_name}' setting is required.")
-            return func(*args, **kwargs)
 
-        return wrapped
-
-    return decorator
-
-
-@settings_required(["MERCHANT_AUTH_LOGIN_ID", "MERCHANT_AUTH_TRANSACTION_KEY"])
 def get_merchant_auth() -> merchantAuthenticationType:
     return merchantAuthenticationType(
         name=str(settings.MERCHANT_AUTH_LOGIN_ID),
@@ -25,11 +19,9 @@ def get_merchant_auth() -> merchantAuthenticationType:
     )
 
 
-@settings_required(["DEBUG"])
 def get_environment() -> str:
     return constants.SANDBOX if settings.DEBUG else constants.PRODUCTION
 
 
-@settings_required(["DEBUG"])
 def get_validation_mode() -> str:
     return "testMode" if settings.DEBUG else "liveMode"

terminusgps/authorizenet/profiles/__init__.py

@@ -0,0 +1,3 @@
+from .addresses import AddressProfile
+from .customers import CustomerProfile
+from .payments import PaymentProfile

terminusgps/authorizenet/profiles/addresses.py

@@ -1,22 +1,22 @@
-from authorizenet.apicontractsv1 import (
-    createCustomerShippingAddressRequest,
-    customerAddressType,
-    deleteCustomerShippingAddressRequest,
-    updateCustomerShippingAddressRequest,
-    getCustomerShippingAddressRequest,
-    getCustomerShippingAddressResponse,
-)
-from authorizenet.apicontrollers import (
-    createCustomerShippingAddressController,
-    deleteCustomerShippingAddressController,
-    getCustomerShippingAddressController,
-    updateCustomerShippingAddressController,
-)
-from terminusgps.authorizenet.profiles.base import AuthorizenetCustomerProfileBase
-
-
-class AddressProfile(AuthorizenetCustomerProfileBase):
+from authorizenet import apicontractsv1, apicontrollers
+from authorizenet.apicontractsv1 import customerAddressType
+
+from terminusgps.authorizenet.profiles.base import AuthorizenetSubProfileBase
+
+
+class AddressProfile(AuthorizenetSubProfileBase):
     def create(self, **kwargs) -> int:
+        """
+        Creates an Authorize.NET address profile.
+
+        :param shipping_addr: An Authorize.NET customer address.
+        :type shipping_addr: :py:obj:`~authorizenet.apicontractsv1.customerAddressType`
+        :raises ValueError: If no customer address was provided.
+        :raises TypeError: If the customer address is not a :py:obj:`~authorizenet.apicontractsv1.customerAddressType` object.
+        :returns: The new address profile's id.
+        :rtype: :py:obj:`int`
+
+        """
         shipping_addr = kwargs.get("shipping_addr")
 
         if not shipping_addr:
@@ -27,57 +27,65 @@ class AddressProfile(AuthorizenetCustomerProfileBase):
                 f"'shipping_addr' must be customerAddressType, got '{type(shipping_addr)}'."
             )
 
-        return self._authorizenet_create_shipping_address(shipping_addr)
+        response = self._authorizenet_create_shipping_address(shipping_addr)
+        return int(response.customerAddressId)
 
-    def delete(self) -> None:
-        self._authorizenet_delete_shipping_address()
+    def update(self, shipping_addr: customerAddressType) -> dict:
+        """Updates the Authorize.NET payment profile."""
+        return self._authorizenet_update_shipping_address(shipping_addr)
 
-    def update(self, shipping_addr: customerAddressType) -> None:
-        self._authorizenet_update_shipping_address(shipping_addr)
+    def delete(self) -> dict:
+        """Deletes the Authorize.NET payment profile."""
+        return self._authorizenet_delete_shipping_address()
 
     def get_details(self) -> dict:
         return self._authorizenet_get_shipping_address()
 
-    def _authorizenet_create_shipping_address(self, addr: customerAddressType) -> int:
-        request = createCustomerShippingAddressRequest(
+    def _authorizenet_get_shipping_address(self) -> dict:
+        assert self.id, "'id' was not set."
+
+        request = apicontractsv1.getCustomerShippingAddressRequest(
             merchantAuthentication=self.merchantAuthentication,
             customerProfileId=self.customerProfileId,
-            address=addr,
-            defaultShippingAddress=self.default,
+            customerAddressId=self.id,
         )
-        controller = createCustomerShippingAddressController(request)
+        controller = apicontrollers.getCustomerShippingAddressController(request)
         response = self.execute_controller(controller)
-        return int(response.customerAddressId)
+        return response
 
-    def _authorizenet_update_shipping_address(self, addr: customerAddressType) -> None:
-        assert self.id, "'id' was not set."
-        addr.customerAddressId = self.id
-        request = updateCustomerShippingAddressRequest(
+    def _authorizenet_create_shipping_address(self, addr: customerAddressType) -> dict:
+        request = apicontractsv1.createCustomerShippingAddressRequest(
             merchantAuthentication=self.merchantAuthentication,
             customerProfileId=self.customerProfileId,
             address=addr,
-            default=self.default,
+            defaultShippingAddress=self.default,
         )
-        controller = updateCustomerShippingAddressController(request)
-        self.execute_controller(controller)
+        controller = apicontrollers.createCustomerShippingAddressController(request)
+        response = self.execute_controller(controller)
+        return response
 
-    def _authorizenet_get_shipping_address(self) -> dict:
+    def _authorizenet_update_shipping_address(self, addr: customerAddressType) -> dict:
         assert self.id, "'id' was not set."
-        request = getCustomerShippingAddressRequest(
+        addr.customerAddressId = self.id
+
+        request = apicontractsv1.updateCustomerShippingAddressRequest(
             merchantAuthentication=self.merchantAuthentication,
             customerProfileId=self.customerProfileId,
-            customerAddressId=self.id,
+            address=addr,
+            default=self.default,
         )
-        controller = getCustomerShippingAddressController(request)
+        controller = apicontrollers.updateCustomerShippingAddressController(request)
         response = self.execute_controller(controller)
         return response
 
-    def _authorizenet_delete_shipping_address(self) -> None:
+    def _authorizenet_delete_shipping_address(self) -> dict:
         assert self.id, "'id' was not set."
-        request = deleteCustomerShippingAddressRequest(
+
+        request = apicontractsv1.deleteCustomerShippingAddressRequest(
             merchantAuthentication=self.merchantAuthentication,
             customerProfileId=self.customerProfileId,
             customerAddressId=self.id,
         )
-        controller = deleteCustomerShippingAddressController(request)
-        self.execute_controller(controller)
+        controller = apicontrollers.deleteCustomerShippingAddressController(request)
+        response = self.execute_controller(controller)
+        return response

terminusgps/authorizenet/profiles/base.py

@@ -1,62 +1,82 @@
+from abc import abstractmethod
+
 from authorizenet.apicontractsv1 import merchantAuthenticationType
-from ..auth import get_environment, get_merchant_auth, get_validation_mode
+from authorizenet.apicontrollersbase import APIOperationBase
+
+from ..auth import get_merchant_auth, get_environment, get_validation_mode
 
 
 class AuthorizenetProfileBase:
-    def __init__(
-        self, merchant_id: int | str, id: int | str | None = None, **kwargs
-    ) -> None:
-        self.merchant_id = merchant_id
-        self.id = str(id) if id else str(self.create(**kwargs))
+    def __init__(self, merchant_id: int | str, id: int | str | None = None) -> None:
+        self._merchantCustomerId = merchant_id
+        self._id = id
 
     def __str__(self) -> str:
         return f"#{self.id}"
 
+    def execute_controller(self, controller: APIOperationBase) -> dict:
+        """
+        Executes an Authorize.NET controller and returns its response.
+
+        :param controller: An Authorize.NET API controller.
+        :raises ValueError: If the API call fails.
+        :returns: The Authorize.NET API response.
+        :rtype: :py:obj:`dict`
+
+        """
+        controller.setenvironment(self.environment)
+        controller.execute()
+        response = controller.getresponse()
+
+        if response.messages.resultCode != "Ok":
+            raise ValueError(response.messages.message[0]["text"].text)
+        return response
+
     @property
-    def environment(self) -> str:
-        return get_environment()
+    def merchantCustomerId(self) -> str:
+        return str(self._merchantCustomerId)
 
     @property
-    def merchantAuthentication(self) -> merchantAuthenticationType:
-        return get_merchant_auth()
+    def id(self) -> str:
+        return str(self._id)
 
     @property
-    def validationMode(self) -> str:
-        return get_validation_mode()
+    def merchantAuthentication(self) -> merchantAuthenticationType:
+        return get_merchant_auth()
 
     @property
-    def merchantCustomerId(self) -> str:
-        return str(self.merchant_id)
+    def environment(self) -> str:
+        return get_environment()
 
+    @abstractmethod
     def create(self, **kwargs) -> int:
         raise NotImplementedError("Subclasses must implement this method.")
 
-    def execute_controller(self, controller):
-        controller.setenvironment(self.environment)
-        controller.execute()
-        response = controller.getresponse()
-        if response.messages.resultCode != "Ok":
-            raise ValueError(response.messages.message[0]["text"].text)
-        return response
+    @abstractmethod
+    def update(self, *args, **kwargs) -> dict:
+        raise NotImplementedError("Subclasses must implement this method.")
+
+    @abstractmethod
+    def delete(self, *args, **kwargs) -> dict:
+        raise NotImplementedError("Subclasses must implement this method.")
 
 
-class AuthorizenetCustomerProfileBase(AuthorizenetProfileBase):
+class AuthorizenetSubProfileBase(AuthorizenetProfileBase):
     def __init__(
-        self, customer_profile_id: int | str, default: bool = False, **kwargs
+        self, customer_profile_id: int | str, default: bool, *args, **kwargs
     ) -> None:
-        if isinstance(customer_profile_id, str) and not customer_profile_id.isdigit():
-            raise ValueError(
-                f"'customer_profile_id' must be a digit, got '{customer_profile_id}'."
-            )
-
+        self._customerProfileId = customer_profile_id
         self._default = default
-        self.customer_profile_id = customer_profile_id
-        return super().__init__(**kwargs)
+        return super().__init__(*args, **kwargs)
 
     @property
-    def customerProfileId(self) -> str:
-        return str(self.customer_profile_id)
+    def validationMode(self) -> str:
+        return get_validation_mode()
 
     @property
     def default(self) -> str:
         return str(self._default).lower()
+
+    @property
+    def customerProfileId(self) -> str:
+        return str(self._customerProfileId)

terminusgps/authorizenet/profiles/customers.py

@@ -1,16 +1,5 @@
-from authorizenet.apicontrollers import (
-    createCustomerProfileController,
-    deleteCustomerProfileController,
-    getCustomerProfileController,
-    updateCustomerProfileController,
-)
-from authorizenet.apicontractsv1 import (
-    customerProfileType,
-    createCustomerProfileRequest,
-    deleteCustomerProfileRequest,
-    getCustomerProfileRequest,
-    updateCustomerProfileRequest,
-)
+from authorizenet import apicontractsv1, apicontrollers
+from authorizenet.apicontractsv1 import customerProfileType
 
 from terminusgps.authorizenet.profiles.base import AuthorizenetProfileBase
 
@@ -31,15 +20,16 @@ class CustomerProfile(AuthorizenetProfileBase):
         if not kwargs.get("email"):
             raise ValueError("'email' is required for creation.")
 
-        return self._authorizenet_create_customer_profile(
-            kwargs["email"], kwargs.get("desc", "")
+        response = self._authorizenet_create_customer_profile(
+            email=kwargs["email"], desc=kwargs.get("desc", "")
         )
+        return int(response.customerProfileId)
 
-    def update(self, email: str, desc: str = "") -> None:
+    def update(self, email: str, desc: str = "") -> dict:
         """Updates the customer profile."""
         return self._authorizenet_update_customer_profile(email, desc)
 
-    def delete(self) -> None:
+    def delete(self) -> dict:
         """Deletes the customer profile."""
         return self._authorizenet_delete_customer_profile()
 
@@ -57,9 +47,11 @@ class CustomerProfile(AuthorizenetProfileBase):
         )
         return addresses if addresses else None
 
-    def _authorizenet_create_customer_profile(self, email: str, desc: str = "") -> int:
+    def _authorizenet_create_customer_profile(
+        self, email: str, desc: str = ""
+    ) -> dict[str, str]:
         """Executes a :py:obj:`~authorizenet.apicontractsv1.createCustomerProfileRequest` using the Authorize.NET API."""
-        request = createCustomerProfileRequest(
+        request = apicontractsv1.createCustomerProfileRequest(
             merchantAuthentication=self.merchantAuthentication,
             profile=customerProfileType(
                 merchantCustomerId=self.merchantCustomerId,
@@ -67,36 +59,28 @@ class CustomerProfile(AuthorizenetProfileBase):
                 description=desc,
             ),
         )
-        controller = createCustomerProfileController(request)
+        controller = apicontrollers.createCustomerProfileController(request)
         response = self.execute_controller(controller)
-        return int(response.customerProfileId)
-
-    def _authorizenet_delete_customer_profile(self) -> None:
-        """Executes a :py:obj:`~authorizenet.apicontractsv1.deleteCustomerProfileRequest` using the Authorize.NET API."""
-        assert self.id, "'id' was not set."
-        request = deleteCustomerProfileRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=str(self.id),
-        )
-        controller = deleteCustomerProfileController(request)
-        self.execute_controller(controller)
+        return response
 
     def _authorizenet_get_customer_profile(self, issuer_info: bool = True) -> dict:
         """Executes a :py:obj:`~authorizenet.apicontractsv1.getCustomerProfileRequest` using the Authorize.NET API."""
         assert self.id, "'id' was not set."
-        request = getCustomerProfileRequest(
+
+        request = apicontractsv1.getCustomerProfileRequest(
             merchantAuthentication=self.merchantAuthentication,
             customerProfileId=self.id,
             includeIssuerInfo=str(issuer_info).lower(),
         )
-        controller = getCustomerProfileController(request)
+        controller = apicontrollers.getCustomerProfileController(request)
         response = self.execute_controller(controller)
         return response
 
-    def _authorizenet_update_customer_profile(self, email: str, desc: str = "") -> None:
+    def _authorizenet_update_customer_profile(self, email: str, desc: str = "") -> dict:
         """Executes an :py:obj:`~authorizenet.apicontractsv1.updateCustomerProfileRequest` using the Authorize.NET API."""
         assert self.id, "'id' was not set."
-        request = updateCustomerProfileRequest(
+
+        request = apicontractsv1.updateCustomerProfileRequest(
             merchantAuthentication=self.merchantAuthentication,
             profile=customerProfileType(
                 merchantCustomerId=self.merchantCustomerId,
@@ -105,5 +89,18 @@ class CustomerProfile(AuthorizenetProfileBase):
                 customerProfileId=self.id,
             ),
         )
-        controller = updateCustomerProfileController(request)
-        self.execute_controller(controller)
+        controller = apicontrollers.updateCustomerProfileController(request)
+        response = self.execute_controller(controller)
+        return response
+
+    def _authorizenet_delete_customer_profile(self) -> dict:
+        """Executes a :py:obj:`~authorizenet.apicontractsv1.deleteCustomerProfileRequest` using the Authorize.NET API."""
+        assert self.id, "'id' was not set."
+
+        request = apicontractsv1.deleteCustomerProfileRequest(
+            merchantAuthentication=self.merchantAuthentication,
+            customerProfileId=self.id,
+        )
+        controller = apicontrollers.deleteCustomerProfileController(request)
+        response = self.execute_controller(controller)
+        return response

terminusgps/authorizenet/profiles/payments.py

@@ -1,25 +1,26 @@
+from authorizenet import apicontractsv1, apicontrollers
 from authorizenet.apicontractsv1 import (
-    createCustomerPaymentProfileRequest,
     customerAddressType,
-    deleteCustomerPaymentProfileRequest,
-    getCustomerPaymentProfileRequest,
-    paymentType,
     customerPaymentProfileType,
-    validateCustomerPaymentProfileRequest,
-    updateCustomerPaymentProfileRequest,
-)
-from authorizenet.apicontrollers import (
-    createCustomerPaymentProfileController,
-    deleteCustomerPaymentProfileController,
-    getCustomerPaymentProfileController,
-    updateCustomerPaymentProfileController,
-    validateCustomerPaymentProfileController,
+    paymentType,
 )
-from terminusgps.authorizenet.profiles.base import AuthorizenetCustomerProfileBase
+
+from terminusgps.authorizenet.profiles.base import AuthorizenetSubProfileBase
 
 
-class PaymentProfile(AuthorizenetCustomerProfileBase):
+class PaymentProfile(AuthorizenetSubProfileBase):
     def create(self, **kwargs) -> int:
+        """
+        Creates an Authorize.NET payment profile.
+
+        :param billing_addr: An Authorize.NET customer address.
+        :type billing_addr: :py:obj:`~authorizenet.apicontractsv1.customerAddressType`
+        :param payment: An Authorize.NET API payment.
+        :type payment: :py:obj:`~authorizenet.apicontractsv1.paymentType`
+        :returns: The new payment profile's id.
+        :rtype: :py:obj:`int`
+
+        """
         billing_addr = kwargs.get("billing_addr")
         payment = kwargs.get("payment")
         if not billing_addr:
@@ -36,43 +37,57 @@ class PaymentProfile(AuthorizenetCustomerProfileBase):
                 f"'payment' must be customerAddressType, got '{type(payment)}'"
             )
 
-        return self._authorizenet_create_payment_profile(billing_addr, payment)
+        response = self._authorizenet_create_payment_profile(billing_addr, payment)
+        return int(response.customerPaymentProfileId)
 
-    def update(self, billing_addr: customerAddressType, payment: paymentType) -> None:
-        self._authorizenet_update_payment_profile(billing_addr, payment)
+    def update(self, billing_addr: customerAddressType, payment: paymentType) -> dict:
+        """Updates the Authorize.NET payment profile."""
+        return self._authorizenet_update_payment_profile(billing_addr, payment)
 
-    def delete(self) -> None:
-        self._authorizenet_delete_payment_profile()
+    def delete(self) -> dict:
+        """Deletes the Authorize.NET payment profile."""
+        return self._authorizenet_delete_payment_profile()
 
     def get_details(self, issuer_info: bool = False) -> dict:
         return self._authorizenet_get_payment_profile(issuer_info)
 
     def _authorizenet_create_payment_profile(
         self, billing_addr: customerAddressType, payment: paymentType
-    ) -> int:
-        """Executes a :py:obj:`~authorizenet.apicontractsv1.createCustomerPaymentProfileRequest` using the Authorize.NET API."""
-        request = createCustomerPaymentProfileRequest(
+    ) -> dict:
+        request = apicontractsv1.createCustomerPaymentProfileRequest(
             customerProfileId=self.customerProfileId,
-            defaultPaymentProfile=self.default,
             merchantAuthentication=self.merchantAuthentication,
             paymentProfile=customerPaymentProfileType(
-                billTo=billing_addr, payment=payment
+                billTo=billing_addr, payment=payment, defaultPaymentProfile=self.default
             ),
             validationMode=self.validationMode,
         )
-        controller = createCustomerPaymentProfileController(request)
+        controller = apicontrollers.createCustomerPaymentProfileController(request)
         response = self.execute_controller(controller)
-        return int(response.customerPaymentProfileId)
+        return response
+
+    def _authorizenet_get_payment_profile(self, issuer_info: bool = False) -> dict:
+        assert self.id, "'id' was not set."
+
+        request = apicontractsv1.getCustomerPaymentProfileRequest(
+            merchantAuthentication=self.merchantAuthentication,
+            customerProfileId=self.customerProfileId,
+            customerPaymentProfileId=self.id,
+            includeIssuerInfo=str(issuer_info).lower(),
+        )
+        controller = apicontrollers.getCustomerPaymentProfileController(request)
+        response = self.execute_controller(controller)
+        return response
 
     def _authorizenet_update_payment_profile(
         self, billing_addr: customerAddressType, payment: paymentType
-    ) -> None:
-        """Executes an :py:obj:`~authorizenet.apicontractsv1.updateCustomerPaymentProfileRequest` using the Authorize.NET API."""
+    ) -> dict:
         assert self.id, "'id' was not set."
-        request = updateCustomerPaymentProfileRequest(
+
+        request = apicontractsv1.updateCustomerPaymentProfileRequest(
             merchantAuthentication=self.merchantAuthentication,
             customerProfileId=self.customerProfileId,
-            paymentProfile=paymentProfile(
+            paymentProfile=customerPaymentProfileType(
                 billTo=billing_addr,
                 payment=payment,
                 defaultPaymentProfile=self.default,
@@ -80,40 +95,31 @@ class PaymentProfile(AuthorizenetCustomerProfileBase):
             ),
             validationMode=self.validationMode,
         )
-        controller = updateCustomerPaymentProfileController(request)
-        self.execute_controller(controller)
+        controller = apicontrollers.updateCustomerPaymentProfileController(request)
+        response = self.execute_controller(controller)
+        return response
 
-    def _authorizenet_get_payment_profile(self, issuer_info: bool = False) -> dict:
-        """Executes a :py:obj:`~authorizenet.apicontractsv1.getCustomerPaymentProfileRequest` using the Authorize.NET API."""
+    def _authorizenet_validate_payment_profile(self) -> dict:
         assert self.id, "'id' was not set."
-        request = getCustomerPaymentProfileRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=self.customerProfileId,
-            customerPaymentProfileId=self.id,
-            includeIssuerInfo=str(issuer_info).lower(),
-        )
-        controller = getCustomerPaymentProfileController(request)
-        return self.execute_controller(controller)
 
-    def _authorizenet_validate_payment_profile(self) -> None:
-        """Executes a :py:obj:`~authorizenet.apicontractsv1.validateCustomerPaymentProfileRequest` using the Authorize.NET API."""
-        assert self.id, "'id' was not set."
-        request = validateCustomerPaymentProfileRequest(
+        request = apicontractsv1.validateCustomerPaymentProfileRequest(
             merchantAuthentication=self.merchantAuthentication,
             customerProfileId=self.customerProfileId,
             customerPaymentProfileId=self.id,
             validationMode=self.validationMode,
         )
-        controller = validateCustomerPaymentProfileController(request)
-        self.execute_controller(controller)
+        controller = apicontrollers.validateCustomerPaymentProfileController(request)
+        response = self.execute_controller(controller)
+        return response
 
-    def _authorizenet_delete_payment_profile(self) -> None:
-        """Executes a :py:obj:`~authorizenet.apicontractsv1.deleteCustomerPaymentProfileRequest` using the Authorize.NET API."""
+    def _authorizenet_delete_payment_profile(self) -> dict:
         assert self.id, "'id' was not set."
-        request = deleteCustomerPaymentProfileRequest(
+
+        request = apicontractsv1.deleteCustomerPaymentProfileRequest(
             merchantAuthentication=self.merchantAuthentication,
             customerProfileId=self.customerProfileId,
             customerPaymentProfileId=self.id,
         )
-        controller = deleteCustomerPaymentProfileController(request)
-        self.execute_controller(controller)
+        controller = apicontrollers.deleteCustomerPaymentProfileController(request)
+        response = self.execute_controller(controller)
+        return response

terminusgps/settings.py

@@ -6,5 +6,3 @@ WIALON_ADMIN_ID = getenv("WIALON_ADMIN_ID")
 WIALON_TOKEN = getenv("WIALON_TOKEN")
 MERCHANT_AUTH_LOGIN_ID = getenv("MERCHANT_AUTH_LOGIN_ID")
 MERCHANT_AUTH_TRANSACTION_KEY = getenv("MERCHANT_AUTH_TRANSACTION_KEY")
-QB_CLIENT_ID = getenv("QB_CLIENT_ID")
-QB_CLIENT_SECRET = getenv("QB_CLIENT_ID")