python-terminusgps 1.7.1__py3-none-any.whl → 1.9.0__py3-none-any.whl

{python_terminusgps-1.7.1.dist-info → python_terminusgps-1.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-terminusgps
-Version: 1.7.1
+Version: 1.9.0
 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
@@ -16,4 +16,6 @@ Requires-Dist: argparse>=1.4.0
 Requires-Dist: authorizenet>=1.1.5
 Requires-Dist: boto3>=1.34.144
 Requires-Dist: django>=5.1.5
+Requires-Dist: intuit-oauth>=1.2.6
+Requires-Dist: python-quickbooks>=0.9.10
 Requires-Dist: python-wialon>=1.2.4

{python_terminusgps-1.7.1.dist-info → python_terminusgps-1.9.0.dist-info}/RECORD

@@ -1,8 +1,11 @@
 terminusgps/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-terminusgps/settings.py,sha256=CIWif9AJYXk5nE-9Mqmqkeoum6-ON5MTuh0WJilgv3E,185
-terminusgps/test.py,sha256=SmvDgRMqLnj_t29eWbckYjK7e9n-Yy-oWwlbN3IdhqE,2004
+terminusgps/settings.py,sha256=fxU6VuJVJaB_tHcIksH-3XPrFQHRD57nW7_9vMsZ6Ag,394
 terminusgps/authorizenet/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-terminusgps/authorizenet/auth.py,sha256=zITSQMH8F-3vw-lDQRbuR2s9AVlGqbOyyFo0zqU00qU,870
+terminusgps/authorizenet/auth.py,sha256=yznomWGTRbFiTDiugsRw1HqxJAV4aJKZFN3Bzdt_V8E,1119
+terminusgps/authorizenet/profiles/addresses.py,sha256=NEm-qxz1wFxnLxd24OqQhHb6AU-C3JRRZOqNgQEN1Xw,3369
+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=peNCn395s1Evk8iK9C9nrk2MsWw8ZHX2-oSgVhNwM1U,5408
 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
@@ -19,7 +22,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.7.1.dist-info/METADATA,sha256=-KAv1c71Uia0KYMDRSjEdmoINaVnCQM64WI-bdebMCA,882
-python_terminusgps-1.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-python_terminusgps-1.7.1.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-python_terminusgps-1.7.1.dist-info/RECORD,,
+python_terminusgps-1.9.0.dist-info/METADATA,sha256=GX0YsG8twa1YTK8fievu8BuFdpnZ5a7DZk8iQvw6S1I,958
+python_terminusgps-1.9.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+python_terminusgps-1.9.0.dist-info/licenses/COPYING,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+python_terminusgps-1.9.0.dist-info/RECORD,,

terminusgps/authorizenet/auth.py

@@ -4,18 +4,32 @@ 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:
-    if not hasattr(settings, "MERCHANT_AUTH_LOGIN_ID"):
-        raise ImproperlyConfigured("'MERCHANT_AUTH_LOGIN_ID' is required.")
-    if not hasattr(settings, "MERCHANT_AUTH_TRANSACTION_KEY"):
-        raise ImproperlyConfigured("'MERCHANT_AUTH_TRANSACTION_KEY' is required.")
     return merchantAuthenticationType(
         name=str(settings.MERCHANT_AUTH_LOGIN_ID),
         transactionKey=str(settings.MERCHANT_AUTH_TRANSACTION_KEY),
     )
 
 
+@settings_required(["DEBUG"])
 def get_environment() -> str:
-    if not hasattr(settings, "DEBUG"):
-        raise ImproperlyConfigured("'DEBUG' is required.")
     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/addresses.py

@@ -0,0 +1,83 @@
+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,
+            default=self.default,
+        )
+        controller = createCustomerShippingAddressController(request)
+        response = self.execute_controller(controller)
+        return int(response.get("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)

terminusgps/authorizenet/profiles/base.py

@@ -0,0 +1,62 @@
+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()

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)

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)

terminusgps/settings.py

@@ -1,6 +1,10 @@
 from os import getenv
 
-DEBUG = False
+DEBUG = True
 SECRET_KEY = "xem*6no%8d9%^qzt2f3x3ar-uq4_+7h9myc$t0!+4%bj5us6f)"
 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")

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()