python-terminusgps 1.8.0__tar.gz → 1.9.1__tar.gz

{python_terminusgps-1.8.0 → python_terminusgps-1.9.1}/PKG-INFO

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

@@ -1,6 +1,6 @@
 [project]
 name = "python-terminusgps"
-version = "1.8.0"
+version = "1.9.1"
 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.8.0 → python_terminusgps-1.9.1}/terminusgps/authorizenet/profiles/addresses.py

@@ -17,44 +17,67 @@ from terminusgps.authorizenet.profiles.base import AuthorizenetCustomerProfileBa
 
 class AddressProfile(AuthorizenetCustomerProfileBase):
     def create(self, **kwargs) -> int:
-        if not kwargs.get("address"):
-            raise ValueError("'address' is required on creation.")
+        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=kwargs["address"],
-            defaultShippingAddress=self.default,
+            address=addr,
+            default=self.default,
         )
         controller = createCustomerShippingAddressController(request)
         response = self.execute_controller(controller)
         return int(response.get("customerAddressId"))
 
-    def delete(self) -> None:
-        request = deleteCustomerShippingAddressRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=self.customerProfileId,
-            customerAddressId=self.id,
-        )
-        controller = deleteCustomerShippingAddressController(request)
-        self.execute_controller(controller)
-
-    def update(self, address: customerAddressType, default: bool = False) -> None:
+    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=address,
-            defaultShippingAddress=default,
+            address=addr,
+            default=self.default,
         )
         controller = updateCustomerShippingAddressController(request)
         self.execute_controller(controller)
-        self._default = default
 
-    def get_details(self) -> getCustomerShippingAddressResponse:
+    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)
-        return self.execute_controller(controller)
+        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.8.0 → python_terminusgps-1.9.1}/terminusgps/authorizenet/profiles/base.py

@@ -7,7 +7,7 @@ class AuthorizenetProfileBase:
         self, merchant_id: int | str, id: int | str | None = None, **kwargs
     ) -> None:
         self.merchant_id = merchant_id
-        self.id = id if id else str(self.create(**kwargs))
+        self.id = str(id) if id else str(self.create(**kwargs))
 
     def __str__(self) -> str:
         return f"#{self.id}"
@@ -59,4 +59,4 @@ class AuthorizenetCustomerProfileBase(AuthorizenetProfileBase):
 
     @property
     def default(self) -> str:
-        return "true" if self._default else "false"
+        return str(self._default).lower()

python_terminusgps-1.9.1/terminusgps/authorizenet/profiles/customers.py

@@ -0,0 +1,109 @@
+from authorizenet.apicontrollers import (
+    createCustomerProfileController,
+    deleteCustomerProfileController,
+    getCustomerProfileController,
+    updateCustomerProfileController,
+)
+from authorizenet.apicontractsv1 import (
+    customerProfileType,
+    createCustomerProfileRequest,
+    deleteCustomerProfileRequest,
+    getCustomerProfileRequest,
+    updateCustomerProfileRequest,
+)
+
+from terminusgps.authorizenet.profiles.base import AuthorizenetProfileBase
+
+
+class CustomerProfile(AuthorizenetProfileBase):
+    def create(self, **kwargs) -> int:
+        """
+        Creates the customer profile.
+
+        :param email: An email address for the customer profile.
+        :type email: :py:obj:`str`
+        :param desc: A description describing the customer profile. Optional.
+        :type desc: :py:obj:`str` | :py:obj:`None`
+        :returns: The new customer profile id.
+        :rtype: :py:obj:`int`
+
+        """
+        if not kwargs.get("email"):
+            raise ValueError("'email' is required for creation.")
+
+        return self._authorizenet_create_customer_profile(
+            kwargs["email"], kwargs.get("desc", "")
+        )
+
+    def update(self, email: str, desc: str = "") -> None:
+        """Updates the customer profile."""
+        return self._authorizenet_update_customer_profile(email, desc)
+
+    def delete(self) -> None:
+        """Deletes the customer profile."""
+        return self._authorizenet_delete_customer_profile()
+
+    def get_payment_profiles(self) -> list[dict] | None:
+        """Retrieves the customer profile's payment profiles list."""
+        profiles = self._authorizenet_get_customer_profile(issuer_info=False).get(
+            "paymentProfiles"
+        )
+        return profiles if profiles else None
+
+    def get_shipping_addresses(self) -> list[dict] | None:
+        """Retrieves the customer profile's shipping address list."""
+        addresses = self._authorizenet_get_customer_profile(issuer_info=False).get(
+            "shipToList"
+        )
+        return addresses if addresses else None
+
+    def _authorizenet_create_customer_profile(self, email: str, desc: str = "") -> int:
+        """Executes a :py:obj:`~authorizenet.apicontractsv1.createCustomerProfileRequest` using the Authorize.NET API."""
+        request = createCustomerProfileRequest(
+            merchantAuthentication=self.merchantAuthentication,
+            profile=customerProfileType(
+                merchantCustomerId=self.merchantCustomerId,
+                email=email,
+                description=desc,
+            ),
+        )
+        controller = 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)
+
+    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(
+            merchantAuthentication=self.merchantAuthentication,
+            customerProfileId=self.id,
+            includeIssuerInfo=str(issuer_info).lower(),
+        )
+        controller = getCustomerProfileController(request)
+        response = self.execute_controller(controller)
+        return response
+
+    def _authorizenet_update_customer_profile(self, email: str, desc: str = "") -> None:
+        """Executes an :py:obj:`~authorizenet.apicontractsv1.updateCustomerProfileRequest` using the Authorize.NET API."""
+        assert self.id, "'id' was not set."
+        request = updateCustomerProfileRequest(
+            merchantAuthentication=self.merchantAuthentication,
+            profile=customerProfileType(
+                merchantCustomerId=self.merchantCustomerId,
+                email=email,
+                description=desc,
+                customerProfileId=self.id,
+            ),
+        )
+        controller = updateCustomerProfileController(request)
+        self.execute_controller(controller)

python_terminusgps-1.9.1/terminusgps/authorizenet/profiles/payments.py

@@ -0,0 +1,118 @@
+from authorizenet.apicontractsv1 import (
+    createCustomerPaymentProfileRequest,
+    customerAddressType,
+    deleteCustomerPaymentProfileRequest,
+    getCustomerPaymentProfileRequest,
+    paymentProfile,
+    paymentType,
+    validateCustomerPaymentProfileRequest,
+    updateCustomerPaymentProfileRequest,
+)
+from authorizenet.apicontrollers import (
+    createCustomerPaymentProfileController,
+    deleteCustomerPaymentProfileController,
+    getCustomerPaymentProfileController,
+    updateCustomerPaymentProfileController,
+    validateCustomerPaymentProfileController,
+)
+from terminusgps.authorizenet.profiles.base import AuthorizenetCustomerProfileBase
+
+
+class PaymentProfile(AuthorizenetCustomerProfileBase):
+    def create(self, **kwargs) -> int:
+        billing_addr = kwargs.get("billing_addr")
+        payment = kwargs.get("payment")
+        if not billing_addr:
+            raise ValueError("'billing_addr' is required on creation.")
+        if not payment:
+            raise ValueError("'payment' is required on creation.")
+
+        if not isinstance(billing_addr, customerAddressType):
+            raise TypeError(
+                f"'billing_addr' must be customerAddressType, got '{type(billing_addr)}'"
+            )
+        if not isinstance(payment, paymentType):
+            raise TypeError(
+                f"'payment' must be customerAddressType, got '{type(payment)}'"
+            )
+
+        return self._authorizenet_create_payment_profile(billing_addr, payment)
+
+    def update(self, billing_addr: customerAddressType, payment: paymentType) -> None:
+        self._authorizenet_update_payment_profile(billing_addr, payment)
+
+    def delete(self) -> None:
+        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,
+            customerProfileId=self.customerProfileId,
+            paymentProfile=paymentProfile(
+                billTo=billing_addr, payment=payment, default=self.default
+            ),
+            validationMode=self.validationMode,
+        )
+        controller = createCustomerPaymentProfileController(request)
+        response = self.execute_controller(controller)
+        return int(response.get("customerPaymentProfileId"))
+
+    def _authorizenet_update_payment_profile(
+        self, billing_addr: customerAddressType, payment: paymentType
+    ) -> None:
+        """Executes an :py:obj:`~authorizenet.apicontractsv1.updateCustomerPaymentProfileRequest` using the Authorize.NET API."""
+        assert self.id, "'id' was not set."
+        request = updateCustomerPaymentProfileRequest(
+            merchantAuthentication=self.merchantAuthentication,
+            customerProfileId=self.customerProfileId,
+            paymentProfile=paymentProfile(
+                billTo=billing_addr,
+                payment=payment,
+                defaultPaymentProfile=self.default,
+                customerPaymentProfileId=self.id,
+            ),
+            validationMode=self.validationMode,
+        )
+        controller = updateCustomerPaymentProfileController(request)
+        self.execute_controller(controller)
+
+    def _authorizenet_get_payment_profile(self, issuer_info: bool = False) -> dict:
+        """Executes a :py:obj:`~authorizenet.apicontractsv1.getCustomerPaymentProfileRequest` using the Authorize.NET API."""
+        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(
+            merchantAuthentication=self.merchantAuthentication,
+            customerProfileId=self.customerProfileId,
+            customerPaymentProfileId=self.id,
+            validationMode=self.validationMode,
+        )
+        controller = validateCustomerPaymentProfileController(request)
+        self.execute_controller(controller)
+
+    def _authorizenet_delete_payment_profile(self) -> None:
+        """Executes a :py:obj:`~authorizenet.apicontractsv1.deleteCustomerPaymentProfileRequest` using the Authorize.NET API."""
+        assert self.id, "'id' was not set."
+        request = deleteCustomerPaymentProfileRequest(
+            merchantAuthentication=self.merchantAuthentication,
+            customerProfileId=self.customerProfileId,
+            customerPaymentProfileId=self.id,
+        )
+        controller = deleteCustomerPaymentProfileController(request)
+        self.execute_controller(controller)

{python_terminusgps-1.8.0 → python_terminusgps-1.9.1}/terminusgps/settings.py

@@ -6,3 +6,5 @@ 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.8.0 → python_terminusgps-1.9.1}/uv.lock

@@ -50,30 +50,30 @@ wheels = [
 
 [[package]]
 name = "boto3"
-version = "1.36.11"
+version = "1.36.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "botocore" },
     { name = "jmespath" },
     { name = "s3transfer" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ee/ac/2b4346474bd3ae501a2fc0e2b5b4f12f412dc89c05bf321a8108d3a95b5c/boto3-1.36.11.tar.gz", hash = "sha256:b40fbf2c0f22e55b67df95475a68bb72be5169097180a875726b6b884339ac8b", size = 111010 }
+sdist = { url = "https://files.pythonhosted.org/packages/04/2b/7365aab02b6768a9694ff43e0e5f1f83f205fc7fe253a410cda990425048/boto3-1.36.12.tar.gz", hash = "sha256:287d84f49bba3255a17b374578127d42b6251e72f55914a62e0ad9ca78c0954b", size = 111048 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4e/a5/e6f90b0a768560a0c44cb9076a313ee6d669ec98fd2747a8451832403ffe/boto3-1.36.11-py3-none-any.whl", hash = "sha256:641dd772eac111d9443258f0f5491c57c2af47bddae94a8d32de19edb5bf7b1c", size = 139177 },
+    { url = "https://files.pythonhosted.org/packages/d0/0b/eb4d244ea84b0fd9e255286a30c98f37f8f28bbf6ea85f7f4b734bf929a9/boto3-1.36.12-py3-none-any.whl", hash = "sha256:32cdf0967287f3ec25a9dc09df0d29cb86b8900c3e0546a63d672775d8127abf", size = 139178 },
 ]
 
 [[package]]
 name = "botocore"
-version = "1.36.11"
+version = "1.36.12"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jmespath" },
     { name = "python-dateutil" },
     { name = "urllib3" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a5/0f/6b92050154ad0e286b82ca36de5f87a466723e1cdc525df53270bcc36f60/botocore-1.36.11.tar.gz", hash = "sha256:c919be883f95b9e0c3021429a365d40cd7944b8345a07af30dc8d891ceefe07a", size = 13497505 }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/54/cc9a665f92534aa105a49dd867f18d4eff4687835994a70a32a103fa11ae/botocore-1.36.12.tar.gz", hash = "sha256:86ed88beb4f244c96529435c868d3940073c2774116f0023fb7691f6e7053bd9", size = 13498321 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2c/ce/e97be00389d51a010c0680ea688a073737ca3b2de6f924800fc61bf68e41/botocore-1.36.11-py3-none-any.whl", hash = "sha256:82c5660027f696608d0e55feb08c146c11c7ebeba7615961c7765dcf6009a00d", size = 13327743 },
+    { url = "https://files.pythonhosted.org/packages/92/3a/5e19d1d1896e86bb9c25f31f5f05ff2e8f40727aa66ee6149b545d3e28b0/botocore-1.36.12-py3-none-any.whl", hash = "sha256:5ae1ed362c8ed908a6ced8cdd12b21e2196c100bc79f9e95c9c1fc7f9ea74f5a", size = 13328293 },
 ]
 
 [[package]]
@@ -285,7 +285,7 @@ wheels = [
 
 [[package]]
 name = "python-terminusgps"
-version = "1.8.0"
+version = "1.9.0"
 source = { editable = "." }
 dependencies = [
     { name = "argparse" },

python_terminusgps-1.8.0/terminusgps/authorizenet/profiles/customers.py

@@ -1,72 +0,0 @@
-from authorizenet.apicontrollers import (
-    createCustomerProfileController,
-    deleteCustomerProfileController,
-    getCustomerProfileController,
-    updateCustomerProfileController,
-)
-from authorizenet.apicontractsv1 import (
-    customerProfileType,
-    createCustomerProfileRequest,
-    deleteCustomerProfileRequest,
-    getCustomerProfileRequest,
-    updateCustomerProfileRequest,
-)
-
-from terminusgps.authorizenet.profiles.base import AuthorizenetProfileBase
-
-
-class CustomerProfile(AuthorizenetProfileBase):
-    def create(self, **kwargs) -> int:
-        if not kwargs.get("email"):
-            raise ValueError("'email' is required for creation.")
-
-        request = createCustomerProfileRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            profile=customerProfileType(
-                merchantCustomerId=self.merchantCustomerId,
-                email=kwargs["email"],
-                description=kwargs.get("desc", ""),
-            ),
-        )
-        controller = createCustomerProfileController(request)
-        response = self.execute_controller(controller)
-        return int(response.customerProfileId)
-
-    def update(self, merchant_id: str, email: str, desc: str = "") -> None:
-        request = updateCustomerProfileRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            profile=CustomerProfile(
-                self.id, merchantCustomerId=merchant_id, email=email, description=desc
-            ),
-        )
-        controller = updateCustomerProfileController(request)
-        self.execute_controller(controller)
-
-    def delete(self) -> None:
-        request = deleteCustomerProfileRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=str(self.id),
-        )
-        controller = deleteCustomerProfileController(request)
-        self.execute_controller(controller)
-
-    @property
-    def payment_profiles(self) -> list[dict]:
-        request = getCustomerProfileRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=self.id,
-            includeIssuerInfo="true",
-        )
-        controller = getCustomerProfileController(request)
-        response = self.execute_controller(controller)
-        return response
-
-
-def main() -> None:
-    profile = CustomerProfile(merchant_id=55, id=522226003)
-    profile.delete()
-    return
-
-
-if __name__ == "__main__":
-    main()

python_terminusgps-1.8.0/terminusgps/authorizenet/profiles/payments.py

@@ -1,90 +0,0 @@
-from authorizenet.apicontractsv1 import (
-    createCustomerPaymentProfileRequest,
-    getCustomerPaymentProfileRequest,
-    deleteCustomerPaymentProfileRequest,
-    paymentProfile,
-    validateCustomerPaymentProfileRequest,
-)
-from authorizenet.apicontrollers import (
-    createCustomerPaymentProfileController,
-    deleteCustomerPaymentProfileController,
-    getCustomerPaymentProfileController,
-    validateCustomerPaymentProfileController,
-)
-from terminusgps.authorizenet.profiles.base import AuthorizenetCustomerProfileBase
-
-
-class PaymentProfile(AuthorizenetCustomerProfileBase):
-    def create(self, **kwargs) -> int:
-        """
-        Creates an Authorize.NET payment profile.
-
-        :param billing_address: A billing address for the payment profile.
-        :type billing_address: :py:obj:`~authorizenet.apicontractsv1.customerAddressType`
-        :param payment: An Authorize.NET API payment object. Usually a credit card, but could be a bank account.
-        :type payment: :py:obj:`~authorizenet.apicontractsv1.paymentType`
-        :param default: Whether or not the payment method should be marked as default. Default is :py:obj:`False`.
-        :type default: :py:obj:`bool`
-        :returns: The new payment profile id.
-        :rtype: :py:obj:`int`
-
-        """
-        if not kwargs.get("billing_address"):
-            raise ValueError("'billing_address' is required on creation.")
-        if not kwargs.get("payment"):
-            raise ValueError("'payment' is required on creation.")
-
-        request = createCustomerPaymentProfileRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=self.customerProfileId,
-            paymentProfile=paymentProfile(
-                billTo=kwargs["billing_address"],
-                payment=kwargs["payment"],
-                defaultPaymentProfile=self.default,
-            ),
-            validationMode=self.validationMode,
-        )
-        controller = createCustomerPaymentProfileController(request)
-        response = self.execute_controller(controller)
-        return int(response.get("customerPaymentProfileId"))
-
-    def delete(self) -> None:
-        """Deletes the Authorize.NET payment profile."""
-        request = deleteCustomerPaymentProfileRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=self.customerProfileId,
-            customerPaymentProfileId=self.id,
-        )
-        controller = deleteCustomerPaymentProfileController(request)
-        self.execute_controller(controller)
-
-    def validate(self) -> None:
-        """Validates the Authorize.NET payment profile."""
-        request = validateCustomerPaymentProfileRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=self.customerProfileId,
-            customerPaymentProfileId=self.id,
-            validationMode=self.validationMode,
-        )
-        controller = validateCustomerPaymentProfileController(request)
-        self.execute_controller(controller)
-
-    def get_details(self, issuer_info: bool = False) -> dict:
-        """
-        Calls the Authorize.NET API and retrieves the payment profile.
-
-        :param issuer_info: Whether or not Authorize.NET should return issuer info for the payment profile.
-        :type issuer_info: :py:obj:`bool`
-        :returns: The Authorize.NET API payment profile.
-        :rtype: :py:obj:`~authorizenet.apicontractsv1.paymentProfile`
-
-        """
-        request = getCustomerPaymentProfileRequest(
-            merchantAuthentication=self.merchantAuthentication,
-            customerProfileId=self.customerProfileId,
-            customerPaymentProfileId=self.id,
-            includeIssuerInfo="true" if issuer_info else "false",
-        )
-        controller = getCustomerPaymentProfileController(request)
-        response = self.execute_controller(controller)
-        return response

python_terminusgps-1.8.0/terminusgps/test.py

@@ -1,55 +0,0 @@
-from django.utils import timezone
-from terminusgps.wialon.session import WialonSession
-from terminusgps.wialon.utils import get_hw_type_id, gen_wialon_password
-from terminusgps.wialon.items import WialonUser, WialonResource, WialonUnit
-from terminusgps.wialon import constants
-
-
-def registration_test() -> None:
-    timestamp = f"{timezone.now():%y-%m-%d-%H:%M:%S}"
-
-    with WialonSession() as session:
-        print(f"Running test '{registration_test.__name__}' as '{session.username}'...")
-        hw_type_id = get_hw_type_id(name="Test HW", session=session)
-
-        super_user = WialonUser(
-            creator_id=session.uid,
-            name=f"super_user_{timestamp}",
-            password=gen_wialon_password(length=32),
-            session=session,
-        )
-        resource = WialonResource(
-            creator_id=super_user.id, name=f"resource_{timestamp}", session=session
-        )
-        unit = WialonUnit(
-            creator_id=session.uid,
-            name=f"test_unit_{timestamp}",
-            hw_type_id=hw_type_id,
-            session=session,
-        )
-        super_user.grant_access(unit, access_mask=constants.ACCESSMASK_UNIT_MIGRATION)
-        resource.create_account("terminusgps_ext_hist")
-        resource.migrate_unit(unit)
-        end_user = WialonUser(
-            creator_id=super_user.id,
-            name=f"end_user_{timestamp}",
-            password=gen_wialon_password(length=32),
-            session=session,
-        )
-        end_user.grant_access(unit, access_mask=constants.ACCESSMASK_UNIT_BASIC)
-
-
-def account_days_test() -> None:
-    timestamp = f"{timezone.now():%y-%m-%d-%H:%M:%S}"
-
-    with WialonSession() as session:
-        print(f"Running test '{account_days_test.__name__}' as '{session.username}'...")
-        account = WialonResource(id="28990259", session=session)
-        account.set_settings_flags(0x20)
-        account.set_minimum_days(0)
-        account.add_days(30)
-
-
-if __name__ == "__main__":
-    registration_test()
-    account_days_test()