python-terminusgps 1.9.3__tar.gz → 1.9.8__tar.gz

{python_terminusgps-1.9.3 → python_terminusgps-1.9.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-terminusgps
-Version: 1.9.3
+Version: 1.9.8
 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.3 → python_terminusgps-1.9.8}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "python-terminusgps"
-version = "1.9.3"
+version = "1.9.8"
 description = "Provides abstractions/utilities for working with Wialon API, Authorize.NET API, AWS API, and more."
 readme = "README.md"
 authors = [ {name = "Blake Nall", email = "blake@terminusgps.com" } ]

python_terminusgps-1.9.8/terminusgps/authorizenet/auth.py

@@ -0,0 +1,27 @@
+from authorizenet.apicontractsv1 import merchantAuthenticationType
+from authorizenet.constants import constants
+
+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 get_merchant_auth() -> merchantAuthenticationType:
+    return merchantAuthenticationType(
+        name=str(settings.MERCHANT_AUTH_LOGIN_ID),
+        transactionKey=str(settings.MERCHANT_AUTH_TRANSACTION_KEY),
+    )
+
+
+def get_environment() -> str:
+    return constants.SANDBOX if settings.DEBUG else constants.PRODUCTION
+
+
+def get_validation_mode() -> str:
+    return "testMode" if settings.DEBUG else "liveMode"

python_terminusgps-1.9.8/terminusgps/authorizenet/profiles/__init__.py

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

python_terminusgps-1.9.8/terminusgps/authorizenet/profiles/addresses.py

@@ -0,0 +1,91 @@
+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:
+            raise ValueError("'shipping_addr' is required on creation.")
+
+        if not isinstance(shipping_addr, customerAddressType):
+            raise TypeError(
+                f"'shipping_addr' must be customerAddressType, got '{type(shipping_addr)}'."
+            )
+
+        response = self._authorizenet_create_shipping_address(shipping_addr)
+        return int(response.customerAddressId)
+
+    def update(self, shipping_addr: customerAddressType) -> dict:
+        """Updates the Authorize.NET payment profile."""
+        return 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_get_shipping_address(self) -> dict:
+        assert self.id, "'id' was not set."
+
+        request = apicontractsv1.getCustomerShippingAddressRequest(
+            merchantAuthentication=self.merchantAuthentication,
+            customerProfileId=self.customerProfileId,
+            customerAddressId=self.id,
+        )
+        controller = apicontrollers.getCustomerShippingAddressController(request)
+        response = self.execute_controller(controller)
+        return response
+
+    def _authorizenet_create_shipping_address(self, addr: customerAddressType) -> dict:
+        request = apicontractsv1.createCustomerShippingAddressRequest(
+            merchantAuthentication=self.merchantAuthentication,
+            customerProfileId=self.customerProfileId,
+            address=addr,
+            defaultShippingAddress=self.default,
+        )
+        controller = apicontrollers.createCustomerShippingAddressController(request)
+        response = self.execute_controller(controller)
+        return response
+
+    def _authorizenet_update_shipping_address(self, addr: customerAddressType) -> dict:
+        assert self.id, "'id' was not set."
+        addr.customerAddressId = self.id
+
+        request = apicontractsv1.updateCustomerShippingAddressRequest(
+            merchantAuthentication=self.merchantAuthentication,
+            customerProfileId=self.customerProfileId,
+            address=addr,
+            default=self.default,
+        )
+        controller = apicontrollers.updateCustomerShippingAddressController(request)
+        response = self.execute_controller(controller)
+        return response
+
+    def _authorizenet_delete_shipping_address(self) -> dict:
+        assert self.id, "'id' was not set."
+
+        request = apicontractsv1.deleteCustomerShippingAddressRequest(
+            merchantAuthentication=self.merchantAuthentication,
+            customerProfileId=self.customerProfileId,
+            customerAddressId=self.id,
+        )
+        controller = apicontrollers.deleteCustomerShippingAddressController(request)
+        response = self.execute_controller(controller)
+        return response

python_terminusgps-1.9.8/terminusgps/authorizenet/profiles/base.py

@@ -0,0 +1,84 @@
+from abc import abstractmethod
+
+from authorizenet.apicontractsv1 import merchantAuthenticationType
+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._merchantCustomerId = merchant_id
+        self._id = str(id) if id else self.create(**kwargs)
+
+    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 merchantCustomerId(self) -> str:
+        return str(self._merchantCustomerId)
+
+    @property
+    def id(self) -> str:
+        return str(self._id)
+
+    @property
+    def merchantAuthentication(self) -> merchantAuthenticationType:
+        return get_merchant_auth()
+
+    @property
+    def environment(self) -> str:
+        return get_environment()
+
+    @abstractmethod
+    def create(self, **kwargs) -> int:
+        raise NotImplementedError("Subclasses must implement this method.")
+
+    @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 AuthorizenetSubProfileBase(AuthorizenetProfileBase):
+    def __init__(
+        self, customer_profile_id: int | str, default: bool, *args, **kwargs
+    ) -> None:
+        self._customerProfileId = customer_profile_id
+        self._default = default
+        return super().__init__(*args, **kwargs)
+
+    @property
+    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)

{python_terminusgps-1.9.3 → python_terminusgps-1.9.8}/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

{python_terminusgps-1.9.3 → python_terminusgps-1.9.8}/terminusgps/authorizenet/profiles/payments.py

@@ -1,25 +1,26 @@
+from authorizenet import apicontractsv1, apicontrollers
 from authorizenet.apicontractsv1 import (
-    createCustomerPaymentProfileRequest,
     customerAddressType,
-    deleteCustomerPaymentProfileRequest,
-    getCustomerPaymentProfileRequest,
-    paymentProfile,
+    customerPaymentProfileType,
     paymentType,
-    validateCustomerPaymentProfileRequest,
-    updateCustomerPaymentProfileRequest,
 )
-from authorizenet.apicontrollers import (
-    createCustomerPaymentProfileController,
-    deleteCustomerPaymentProfileController,
-    getCustomerPaymentProfileController,
-    updateCustomerPaymentProfileController,
-    validateCustomerPaymentProfileController,
-)
-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(
-            merchantAuthentication=self.merchantAuthentication,
+    ) -> dict:
+        request = apicontractsv1.createCustomerPaymentProfileRequest(
             customerProfileId=self.customerProfileId,
-            paymentProfile=paymentProfile(
-                billTo=billing_addr, payment=payment, default=self.default
+            merchantAuthentication=self.merchantAuthentication,
+            paymentProfile=customerPaymentProfileType(
+                billTo=billing_addr, payment=payment, defaultPaymentProfile=self.default
             ),
             validationMode=self.validationMode,
-            defaultPaymentProfile=self.default,
         )
-        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

{python_terminusgps-1.9.3 → python_terminusgps-1.9.8}/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")

{python_terminusgps-1.9.3 → python_terminusgps-1.9.8}/uv.lock

@@ -285,7 +285,7 @@ wheels = [
 
 [[package]]
 name = "python-terminusgps"
-version = "1.9.2"
+version = "1.9.8"
 source = { editable = "." }
 dependencies = [
     { name = "argparse" },

python_terminusgps-1.9.3/terminusgps/authorizenet/auth.py

@@ -1,35 +0,0 @@
-from authorizenet.apicontractsv1 import merchantAuthenticationType
-from authorizenet.constants import constants
-
-from django.conf import ImproperlyConfigured, settings
-
-
-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),
-        transactionKey=str(settings.MERCHANT_AUTH_TRANSACTION_KEY),
-    )
-
-
-@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"

python_terminusgps-1.9.3/terminusgps/authorizenet/profiles/addresses.py

@@ -1,83 +0,0 @@
-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):
-    def create(self, **kwargs) -> int:
-        shipping_addr = kwargs.get("shipping_addr")
-
-        if not shipping_addr:
-            raise ValueError("'shipping_addr' is required on creation.")
-
-        if not isinstance(shipping_addr, customerAddressType):
-            raise TypeError(
-                f"'shipping_addr' must be customerAddressType, got '{type(shipping_addr)}'."
-            )
-
-        return self._authorizenet_create_shipping_address(shipping_addr)
-
-    def delete(self) -> None:
-        self._authorizenet_delete_shipping_address()
-
-    def update(self, shipping_addr: customerAddressType) -> None:
-        self._authorizenet_update_shipping_address(shipping_addr)
-
-    def get_details(self) -> dict:
-        return self._authorizenet_get_shipping_address()
-
-    def _authorizenet_create_shipping_address(self, addr: customerAddressType) -> int:
-        request = createCustomerShippingAddressRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=self.customerProfileId,
-            address=addr,
-            defaultShippingAddress=self.default,
-        )
-        controller = createCustomerShippingAddressController(request)
-        response = self.execute_controller(controller)
-        return int(response.customerAddressId)
-
-    def _authorizenet_update_shipping_address(self, addr: customerAddressType) -> None:
-        assert self.id, "'id' was not set."
-        addr.customerAddressId = self.id
-        request = updateCustomerShippingAddressRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=self.customerProfileId,
-            address=addr,
-            default=self.default,
-        )
-        controller = updateCustomerShippingAddressController(request)
-        self.execute_controller(controller)
-
-    def _authorizenet_get_shipping_address(self) -> dict:
-        assert self.id, "'id' was not set."
-        request = getCustomerShippingAddressRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=self.customerProfileId,
-            customerAddressId=self.id,
-        )
-        controller = getCustomerShippingAddressController(request)
-        response = self.execute_controller(controller)
-        return response
-
-    def _authorizenet_delete_shipping_address(self) -> None:
-        assert self.id, "'id' was not set."
-        request = deleteCustomerShippingAddressRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=self.customerProfileId,
-            customerAddressId=self.id,
-        )
-        controller = deleteCustomerShippingAddressController(request)
-        self.execute_controller(controller)

python_terminusgps-1.9.3/terminusgps/authorizenet/profiles/base.py

@@ -1,62 +0,0 @@
-from authorizenet.apicontractsv1 import merchantAuthenticationType
-from ..auth import get_environment, get_merchant_auth, 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 __str__(self) -> str:
-        return f"#{self.id}"
-
-    @property
-    def environment(self) -> str:
-        return get_environment()
-
-    @property
-    def merchantAuthentication(self) -> merchantAuthenticationType:
-        return get_merchant_auth()
-
-    @property
-    def validationMode(self) -> str:
-        return get_validation_mode()
-
-    @property
-    def merchantCustomerId(self) -> str:
-        return str(self.merchant_id)
-
-    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
-
-
-class AuthorizenetCustomerProfileBase(AuthorizenetProfileBase):
-    def __init__(
-        self, customer_profile_id: int | str, default: bool = False, **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._default = default
-        self.customer_profile_id = customer_profile_id
-        return super().__init__(**kwargs)
-
-    @property
-    def customerProfileId(self) -> str:
-        return str(self.customer_profile_id)
-
-    @property
-    def default(self) -> str:
-        return str(self._default).lower()