feat(pay_later): add loan precalculation endpoint (#2)

feat(pay_later): add loan precalculation endpoint

Author: luboSB-47

tatrapayplus/client.py

@@ -25,6 +25,8 @@
     trim_and_remove_special_characters,
 )
 from tatrapayplus.models import (
+    BasicCalculationRequest,
+    BasicCalculationResponseItem,
     Field40XErrorBody,
     Field400ErrorBody,
     GetAccessTokenResponse400,
@@ -253,6 +255,21 @@ def set_appearance_logo(self, request: AppearanceLogoRequest) -> Response:
         self.session.headers = self.get_default_headers()
         return self.handle_response(self.session.post(url, json=request.to_dict()))
 
+    def precalculate_loan(
+        self, request: BasicCalculationRequest, ip_address: str
+    ) -> list[BasicCalculationResponseItem]:
+        loan_offers: list[BasicCalculationResponseItem] = []
+
+        url = f"{self.base_url}{Urls.LOAN_PRECALCULATION}"
+        self.session.headers = self.get_default_headers()
+        self.session.headers["IP-Address"] = ip_address
+
+        response = self.handle_response(self.session.put(url, json=request.to_dict()))
+        for loan_item in response.json():
+            loan_offers.append(BasicCalculationResponseItem.from_dict(loan_item))
+
+        return loan_offers
+
     @staticmethod
     def generate_signed_card_id_from_cid(cid: str, public_key_content: Optional[str] = None) -> Optional[str]:
         if public_key_content is None:

tatrapayplus/enums.py

@@ -15,6 +15,7 @@ class Urls:
     STATUS = "/status"
     APPEARANCES = "/v1/appearances"
     APPEARANCE_LOGO = APPEARANCES + "/logo"
+    LOAN_PRECALCULATION = "/v1/payments/loans/precalculation"
 
 
 class SimpleStatus(str, Enum):

tatrapayplus/models/__init__.py

@@ -15,6 +15,9 @@
 from .bank_transfer import BankTransfer
 from .bank_transfer_status import BankTransferStatus
 from .base_payment import BasePayment
+from .basic_calculation_request import BasicCalculationRequest
+from .basic_calculation_request_payment_method import BasicCalculationRequestPaymentMethod
+from .basic_calculation_response_item import BasicCalculationResponseItem
 from .capacity_info import CapacityInfo
 from .card_detail import CardDetail
 from .card_detail_card_pay_lang_override import CardDetailCardPayLangOverride
@@ -28,7 +31,6 @@
 from .comfort_pay import ComfortPay
 from .comfort_pay_status import ComfortPayStatus
 from .direct_transaction_data import DirectTransactionData
-from .direct_transaction_ipsp_data import DirectTransactionIPSPData
 from .direct_transaction_status import DirectTransactionStatus
 from .direct_transaction_task_status_response import DirectTransactionTaskStatusResponse
 from .direct_transaction_tds_data import DirectTransactionTDSData
@@ -62,6 +64,7 @@
 from .register_for_comfort_pay_obj import RegisterForComfortPayObj
 from .signed_card_id_obj import SignedCardIdObj
 from .status import Status
+from .transaction_ipsp_data import TransactionIPSPData
 from .user_data import UserData
 
 __all__ = (
@@ -80,6 +83,9 @@
     "BankTransfer",
     "BankTransferStatus",
     "BasePayment",
+    "BasicCalculationRequest",
+    "BasicCalculationRequestPaymentMethod",
+    "BasicCalculationResponseItem",
     "CapacityInfo",
     "CardDetail",
     "CardDetailCardPayLangOverride",
@@ -93,7 +99,6 @@
     "ComfortPay",
     "ComfortPayStatus",
     "DirectTransactionData",
-    "DirectTransactionIPSPData",
     "DirectTransactionStatus",
     "DirectTransactionTaskStatusResponse",
     "DirectTransactionTDSData",
@@ -127,5 +132,6 @@
     "RegisterForComfortPayObj",
     "SignedCardIdObj",
     "Status",
+    "TransactionIPSPData",
     "UserData",
 )

tatrapayplus/models/bank_transfer.py

@@ -14,10 +14,25 @@ class BankTransfer:
     """Bank transder attributes
 
     Attributes:
-        remittance_information_unstructured (Union[Unset, str]): Unstructured remittance information. At present,
-            Tatrabanka bank transfer does not display the remittance information. SEPA remittanceInformationUnstructured
-            contains 140 characters. For TatraPayPlus purposes, the first up to 40 characters are assigned to the paymentId.
-            Others 100 characters are free to use
+        remittance_information_unstructured (Union[Unset, str]): Unstructured transfer information. Currently,
+            Tatrabanka bank transfer does not display the transfer information. The entire SEPA
+            remittanceInformationUnstructured contains 140 characters. The structure of the string consists of 3 parts:
+
+                - A. paymentId - fixed 40 characters are reserved for paymentId
+                - B. Merchant Name value length - provided in the contract, up to 50 characters
+                - C. Custom value length - free characters are calculated as C = 140-A-(B+1). Depends on the length of the
+            merchant name.
+
+                E.g. Merchant name = MerchantABCD,s.r.o. (19 characters + 1 separator space). 80 characters are available.
+
+                The result of the UnstructuredTransferInformation will look like this
+
+                07b940d2-8b82-4c7a-a0dd-5ebeabcf1f3d MerchantABCD,s.r.o. Your text in remittance
+
+                If the value of RemittanceInformationUnstructured in this attribute is longer than the calculated C, your
+            custom value will be truncated.
+
+
              Example: Ref Number Merchant.
     """
 

tatrapayplus/models/basic_calculation_request.py

@@ -0,0 +1,104 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..models.basic_calculation_request_payment_method import (
+    BasicCalculationRequestPaymentMethod,
+)
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+    from ..models.capacity_info import CapacityInfo
+
+
+T = TypeVar("T", bound="BasicCalculationRequest")
+
+
+@_attrs_define
+class BasicCalculationRequest:
+    """
+    Attributes:
+        loan_amount (float): Loan amount in EUR Example: 156.95.
+        payment_method (Union[Unset, BasicCalculationRequestPaymentMethod]): Only if isPrecalculationAllowed = true
+        capacity_info (Union[Unset, CapacityInfo]): Capacity posibilities of user. It is used to specify the calculation
+            of the client's request. Based on this, the bank can make a more accurate calculation of the possibility of
+            obtaining a loan
+    """
+
+    loan_amount: float
+    payment_method: Union[Unset, BasicCalculationRequestPaymentMethod] = UNSET
+    capacity_info: Union[Unset, "CapacityInfo"] = UNSET
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        loan_amount = self.loan_amount
+
+        payment_method: Union[Unset, str] = UNSET
+        if not isinstance(self.payment_method, Unset):
+            payment_method = self.payment_method.value
+
+        capacity_info: Union[Unset, dict[str, Any]] = UNSET
+        if not isinstance(self.capacity_info, Unset):
+            capacity_info = self.capacity_info.to_dict()
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "loanAmount": loan_amount,
+            }
+        )
+        if payment_method is not UNSET:
+            field_dict["paymentMethod"] = payment_method
+        if capacity_info is not UNSET:
+            field_dict["capacityInfo"] = capacity_info
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        from ..models.capacity_info import CapacityInfo
+
+        d = dict(src_dict)
+        loan_amount = d.pop("loanAmount")
+
+        _payment_method = d.pop("paymentMethod", UNSET)
+        payment_method: Union[Unset, BasicCalculationRequestPaymentMethod]
+        if isinstance(_payment_method, Unset):
+            payment_method = UNSET
+        else:
+            payment_method = BasicCalculationRequestPaymentMethod(_payment_method)
+
+        _capacity_info = d.pop("capacityInfo", UNSET)
+        capacity_info: Union[Unset, CapacityInfo]
+        if isinstance(_capacity_info, Unset):
+            capacity_info = UNSET
+        else:
+            capacity_info = CapacityInfo.from_dict(_capacity_info)
+
+        basic_calculation_request = cls(
+            loan_amount=loan_amount,
+            payment_method=payment_method,
+            capacity_info=capacity_info,
+        )
+
+        basic_calculation_request.additional_properties = d
+        return basic_calculation_request
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties

tatrapayplus/models/basic_calculation_request_payment_method.py

@@ -0,0 +1,8 @@
+from enum import Enum
+
+
+class BasicCalculationRequestPaymentMethod(str, Enum):
+    PAY_LATER = "PAY_LATER"
+
+    def __str__(self) -> str:
+        return str(self.value)

tatrapayplus/models/basic_calculation_response_item.py

@@ -0,0 +1,123 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="BasicCalculationResponseItem")
+
+
+@_attrs_define
+class BasicCalculationResponseItem:
+    """
+    Attributes:
+        loan_interest_rate (float): Loan interest rate
+        installment_amount (float): Installment amount
+        loan_duration (int): Loan duration
+        preference (bool): Preferred maturity of loan offer (max 3)
+        main_preference (bool): Main preferred maturity of loan offer (max 1)
+        capacity_validity (bool): Loan offer is valid with respect to entered capacity
+        rpmn (float): Calculated RPMN
+        total_amount (float): Total amount of the order including all fees, insurance, shipping,... Example: 156.95.
+        loan_fee (float):
+    """
+
+    loan_interest_rate: float
+    installment_amount: float
+    loan_duration: int
+    preference: bool
+    main_preference: bool
+    capacity_validity: bool
+    rpmn: float
+    total_amount: float
+    loan_fee: float
+    additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+    def to_dict(self) -> dict[str, Any]:
+        loan_interest_rate = self.loan_interest_rate
+
+        installment_amount = self.installment_amount
+
+        loan_duration = self.loan_duration
+
+        preference = self.preference
+
+        main_preference = self.main_preference
+
+        capacity_validity = self.capacity_validity
+
+        rpmn = self.rpmn
+
+        total_amount = self.total_amount
+
+        loan_fee = self.loan_fee
+
+        field_dict: dict[str, Any] = {}
+        field_dict.update(self.additional_properties)
+        field_dict.update(
+            {
+                "loanInterestRate": loan_interest_rate,
+                "installmentAmount": installment_amount,
+                "loanDuration": loan_duration,
+                "preference": preference,
+                "mainPreference": main_preference,
+                "capacityValidity": capacity_validity,
+                "rpmn": rpmn,
+                "totalAmount": total_amount,
+                "loanFee": loan_fee,
+            }
+        )
+
+        return field_dict
+
+    @classmethod
+    def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+        d = dict(src_dict)
+        loan_interest_rate = d.pop("loanInterestRate")
+
+        installment_amount = d.pop("installmentAmount")
+
+        loan_duration = d.pop("loanDuration")
+
+        preference = d.pop("preference")
+
+        main_preference = d.pop("mainPreference")
+
+        capacity_validity = d.pop("capacityValidity")
+
+        rpmn = d.pop("rpmn")
+
+        total_amount = d.pop("totalAmount")
+
+        loan_fee = d.pop("loanFee")
+
+        basic_calculation_response_item = cls(
+            loan_interest_rate=loan_interest_rate,
+            installment_amount=installment_amount,
+            loan_duration=loan_duration,
+            preference=preference,
+            main_preference=main_preference,
+            capacity_validity=capacity_validity,
+            rpmn=rpmn,
+            total_amount=total_amount,
+            loan_fee=loan_fee,
+        )
+
+        basic_calculation_response_item.additional_properties = d
+        return basic_calculation_response_item
+
+    @property
+    def additional_keys(self) -> list[str]:
+        return list(self.additional_properties.keys())
+
+    def __getitem__(self, key: str) -> Any:
+        return self.additional_properties[key]
+
+    def __setitem__(self, key: str, value: Any) -> None:
+        self.additional_properties[key] = value
+
+    def __delitem__(self, key: str) -> None:
+        del self.additional_properties[key]
+
+    def __contains__(self, key: str) -> bool:
+        return key in self.additional_properties