onlinepayments-sdk-python3 5.1.0__zip → 6.1.0__zip

onlinepayments_sdk_python3-6.1.0/onlinepayments/sdk/domain/card_essentials.py

@@ -0,0 +1,438 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from datetime import date
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CardEssentials(DataObject):
+
+    __bin: Optional[str] = None
+    __card_corporate_indicator: Optional[bool] = None
+    __card_effective_date: Optional[date] = None
+    __card_effective_date_indicator: Optional[bool] = None
+    __card_number: Optional[str] = None
+    __card_pan_type: Optional[str] = None
+    __card_product_code: Optional[str] = None
+    __card_product_name: Optional[str] = None
+    __card_product_usage_label: Optional[str] = None
+    __card_scheme: Optional[str] = None
+    __card_type: Optional[str] = None
+    __country_code: Optional[str] = None
+    __expiry_date: Optional[str] = None
+    __issuer_code: Optional[str] = None
+    __issuer_name: Optional[str] = None
+    __issuer_region_code: Optional[str] = None
+    __issuing_country_code: Optional[str] = None
+    __pan_length_max: Optional[int] = None
+    __pan_length_min: Optional[int] = None
+    __pan_luhn_check: Optional[bool] = None
+    __virtual_card_indicator: Optional[bool] = None
+
+    @property
+    def bin(self) -> Optional[str]:
+        """
+        | The first digits of the credit card number from left to right with a minimum of 6 digits.
+
+        Type: str
+        """
+        return self.__bin
+
+    @bin.setter
+    def bin(self, value: Optional[str]) -> None:
+        self.__bin = value
+
+    @property
+    def card_corporate_indicator(self) -> Optional[bool]:
+        """
+        | Indicates whether the card is an Enterprise / Commercial card or not
+
+        Type: bool
+        """
+        return self.__card_corporate_indicator
+
+    @card_corporate_indicator.setter
+    def card_corporate_indicator(self, value: Optional[bool]) -> None:
+        self.__card_corporate_indicator = value
+
+    @property
+    def card_effective_date(self) -> Optional[date]:
+        """
+        | The card effective date (YYYY-MM-DD)
+
+        Type: date
+        """
+        return self.__card_effective_date
+
+    @card_effective_date.setter
+    def card_effective_date(self, value: Optional[date]) -> None:
+        self.__card_effective_date = value
+
+    @property
+    def card_effective_date_indicator(self) -> Optional[bool]:
+        """
+        | Indicator of existence of a card effective date
+
+        Type: bool
+        """
+        return self.__card_effective_date_indicator
+
+    @card_effective_date_indicator.setter
+    def card_effective_date_indicator(self, value: Optional[bool]) -> None:
+        self.__card_effective_date_indicator = value
+
+    @property
+    def card_number(self) -> Optional[str]:
+        """
+        | The masked credit/debit card number
+
+        Type: str
+        """
+        return self.__card_number
+
+    @card_number.setter
+    def card_number(self, value: Optional[str]) -> None:
+        self.__card_number = value
+
+    @property
+    def card_pan_type(self) -> Optional[str]:
+        """
+        | PAN type sent
+        
+        * ``dpan`` Digital PAN
+        * ``pan`` Real PAN
+
+        Type: str
+        """
+        return self.__card_pan_type
+
+    @card_pan_type.setter
+    def card_pan_type(self, value: Optional[str]) -> None:
+        self.__card_pan_type = value
+
+    @property
+    def card_product_code(self) -> Optional[str]:
+        """
+        | Product code of the card
+
+        Type: str
+        """
+        return self.__card_product_code
+
+    @card_product_code.setter
+    def card_product_code(self, value: Optional[str]) -> None:
+        self.__card_product_code = value
+
+    @property
+    def card_product_name(self) -> Optional[str]:
+        """
+        | Product name of the card
+
+        Type: str
+        """
+        return self.__card_product_name
+
+    @card_product_name.setter
+    def card_product_name(self, value: Optional[str]) -> None:
+        self.__card_product_name = value
+
+    @property
+    def card_product_usage_label(self) -> Optional[str]:
+        """
+        | Profile name of the card which is displayed on payment electronic ticket in accordance with MPADS requirements
+        
+        * ``commercial`` Business card
+        * ``credit`` Credit card
+        * ``debit`` Debit card
+        * ``prepaid`` Prepaid card
+
+        Type: str
+        """
+        return self.__card_product_usage_label
+
+    @card_product_usage_label.setter
+    def card_product_usage_label(self, value: Optional[str]) -> None:
+        self.__card_product_usage_label = value
+
+    @property
+    def card_scheme(self) -> Optional[str]:
+        """
+        | Network name associated with the card that is informational only and not to be coded against
+        
+        * ``AmericanExpress`` American Express scheme
+        * ``Bancontact`` Bancontact scheme
+        * ``Cb`` Cartes Bancaires scheme
+        * ``Cup`` China UnionPay scheme
+        * ``Dankort`` Dankort scheme
+        * ``DinersDiscover`` Diners Discover scheme
+        * ``Eftpos`` eftpos scheme
+        * ``Jcb`` Japan Credit Bureau scheme
+        * ``Mastercard`` Mastercard scheme
+        * ``Oney`` Oney scheme
+        * ``Uatp`` Universal Air Travel Plan scheme
+        * ``Visa`` Visa scheme
+
+        Type: str
+        """
+        return self.__card_scheme
+
+    @card_scheme.setter
+    def card_scheme(self, value: Optional[str]) -> None:
+        self.__card_scheme = value
+
+    @property
+    def card_type(self) -> Optional[str]:
+        """
+        | The card's type as categorised by the payment method. Possible values are:
+        
+        * Credit
+        * Debit
+        * Prepaid
+
+        Type: str
+        """
+        return self.__card_type
+
+    @card_type.setter
+    def card_type(self, value: Optional[str]) -> None:
+        self.__card_type = value
+
+    @property
+    def country_code(self) -> Optional[str]:
+        """
+        | ISO 3166-1 alpha-2 country code
+
+        Type: str
+        """
+        return self.__country_code
+
+    @country_code.setter
+    def country_code(self, value: Optional[str]) -> None:
+        self.__country_code = value
+
+    @property
+    def expiry_date(self) -> Optional[str]:
+        """
+        | Expiry date of the card Format: MMYY
+
+        Type: str
+        """
+        return self.__expiry_date
+
+    @expiry_date.setter
+    def expiry_date(self, value: Optional[str]) -> None:
+        self.__expiry_date = value
+
+    @property
+    def issuer_code(self) -> Optional[str]:
+        """
+        | Issuer code of the card
+
+        Type: str
+        """
+        return self.__issuer_code
+
+    @issuer_code.setter
+    def issuer_code(self, value: Optional[str]) -> None:
+        self.__issuer_code = value
+
+    @property
+    def issuer_name(self) -> Optional[str]:
+        """
+        | Issuer name of the card
+
+        Type: str
+        """
+        return self.__issuer_name
+
+    @issuer_name.setter
+    def issuer_name(self, value: Optional[str]) -> None:
+        self.__issuer_name = value
+
+    @property
+    def issuer_region_code(self) -> Optional[str]:
+        """
+        | Region code of the card issuer
+        
+        * ``1`` USA: California, Hawaii, Nevada
+        * ``2`` USA: West except California, Hawaii, Nevada
+        * ``3`` USA: Central North
+        * ``4`` USA: Central South
+        * ``5`` USA: Great Lakes states
+        * ``6`` USA: South East
+        * ``7`` USA: Extreme North East
+        * ``8`` USA: North East
+        * ``9`` USA: Florida and Georgia
+        * ``a`` Canada
+        * ``b`` South America
+        * ``c`` Oceania and Asia
+        * ``d`` Europe
+        * ``e`` Africa and Middle East
+
+        Type: str
+        """
+        return self.__issuer_region_code
+
+    @issuer_region_code.setter
+    def issuer_region_code(self, value: Optional[str]) -> None:
+        self.__issuer_region_code = value
+
+    @property
+    def issuing_country_code(self) -> Optional[str]:
+        """
+        | ISO 3166-1 alpha-2 country code in which the card has been issued
+
+        Type: str
+        """
+        return self.__issuing_country_code
+
+    @issuing_country_code.setter
+    def issuing_country_code(self, value: Optional[str]) -> None:
+        self.__issuing_country_code = value
+
+    @property
+    def pan_length_max(self) -> Optional[int]:
+        """
+        | Maximum length of the PAN
+
+        Type: int
+        """
+        return self.__pan_length_max
+
+    @pan_length_max.setter
+    def pan_length_max(self, value: Optional[int]) -> None:
+        self.__pan_length_max = value
+
+    @property
+    def pan_length_min(self) -> Optional[int]:
+        """
+        | Minimal length of the PAN
+
+        Type: int
+        """
+        return self.__pan_length_min
+
+    @pan_length_min.setter
+    def pan_length_min(self, value: Optional[int]) -> None:
+        self.__pan_length_min = value
+
+    @property
+    def pan_luhn_check(self) -> Optional[bool]:
+        """
+        | Indicates whether the PAN is controlled with Lühn Key algorithm
+
+        Type: bool
+        """
+        return self.__pan_luhn_check
+
+    @pan_luhn_check.setter
+    def pan_luhn_check(self, value: Optional[bool]) -> None:
+        self.__pan_luhn_check = value
+
+    @property
+    def virtual_card_indicator(self) -> Optional[bool]:
+        """
+        | Indicates whether the card is a virtual card
+
+        Type: bool
+        """
+        return self.__virtual_card_indicator
+
+    @virtual_card_indicator.setter
+    def virtual_card_indicator(self, value: Optional[bool]) -> None:
+        self.__virtual_card_indicator = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CardEssentials, self).to_dictionary()
+        if self.bin is not None:
+            dictionary['bin'] = self.bin
+        if self.card_corporate_indicator is not None:
+            dictionary['cardCorporateIndicator'] = self.card_corporate_indicator
+        if self.card_effective_date is not None:
+            dictionary['cardEffectiveDate'] = DataObject.format_date(self.card_effective_date)
+        if self.card_effective_date_indicator is not None:
+            dictionary['cardEffectiveDateIndicator'] = self.card_effective_date_indicator
+        if self.card_number is not None:
+            dictionary['cardNumber'] = self.card_number
+        if self.card_pan_type is not None:
+            dictionary['cardPanType'] = self.card_pan_type
+        if self.card_product_code is not None:
+            dictionary['cardProductCode'] = self.card_product_code
+        if self.card_product_name is not None:
+            dictionary['cardProductName'] = self.card_product_name
+        if self.card_product_usage_label is not None:
+            dictionary['cardProductUsageLabel'] = self.card_product_usage_label
+        if self.card_scheme is not None:
+            dictionary['cardScheme'] = self.card_scheme
+        if self.card_type is not None:
+            dictionary['cardType'] = self.card_type
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.expiry_date is not None:
+            dictionary['expiryDate'] = self.expiry_date
+        if self.issuer_code is not None:
+            dictionary['issuerCode'] = self.issuer_code
+        if self.issuer_name is not None:
+            dictionary['issuerName'] = self.issuer_name
+        if self.issuer_region_code is not None:
+            dictionary['issuerRegionCode'] = self.issuer_region_code
+        if self.issuing_country_code is not None:
+            dictionary['issuingCountryCode'] = self.issuing_country_code
+        if self.pan_length_max is not None:
+            dictionary['panLengthMax'] = self.pan_length_max
+        if self.pan_length_min is not None:
+            dictionary['panLengthMin'] = self.pan_length_min
+        if self.pan_luhn_check is not None:
+            dictionary['panLuhnCheck'] = self.pan_luhn_check
+        if self.virtual_card_indicator is not None:
+            dictionary['virtualCardIndicator'] = self.virtual_card_indicator
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CardEssentials':
+        super(CardEssentials, self).from_dictionary(dictionary)
+        if 'bin' in dictionary:
+            self.bin = dictionary['bin']
+        if 'cardCorporateIndicator' in dictionary:
+            self.card_corporate_indicator = dictionary['cardCorporateIndicator']
+        if 'cardEffectiveDate' in dictionary:
+            self.card_effective_date = DataObject.parse_date(dictionary['cardEffectiveDate'])
+        if 'cardEffectiveDateIndicator' in dictionary:
+            self.card_effective_date_indicator = dictionary['cardEffectiveDateIndicator']
+        if 'cardNumber' in dictionary:
+            self.card_number = dictionary['cardNumber']
+        if 'cardPanType' in dictionary:
+            self.card_pan_type = dictionary['cardPanType']
+        if 'cardProductCode' in dictionary:
+            self.card_product_code = dictionary['cardProductCode']
+        if 'cardProductName' in dictionary:
+            self.card_product_name = dictionary['cardProductName']
+        if 'cardProductUsageLabel' in dictionary:
+            self.card_product_usage_label = dictionary['cardProductUsageLabel']
+        if 'cardScheme' in dictionary:
+            self.card_scheme = dictionary['cardScheme']
+        if 'cardType' in dictionary:
+            self.card_type = dictionary['cardType']
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'expiryDate' in dictionary:
+            self.expiry_date = dictionary['expiryDate']
+        if 'issuerCode' in dictionary:
+            self.issuer_code = dictionary['issuerCode']
+        if 'issuerName' in dictionary:
+            self.issuer_name = dictionary['issuerName']
+        if 'issuerRegionCode' in dictionary:
+            self.issuer_region_code = dictionary['issuerRegionCode']
+        if 'issuingCountryCode' in dictionary:
+            self.issuing_country_code = dictionary['issuingCountryCode']
+        if 'panLengthMax' in dictionary:
+            self.pan_length_max = dictionary['panLengthMax']
+        if 'panLengthMin' in dictionary:
+            self.pan_length_min = dictionary['panLengthMin']
+        if 'panLuhnCheck' in dictionary:
+            self.pan_luhn_check = dictionary['panLuhnCheck']
+        if 'virtualCardIndicator' in dictionary:
+            self.virtual_card_indicator = dictionary['virtualCardIndicator']
+        return self

{onlinepayments_sdk_python3-5.1.0 → onlinepayments_sdk_python3-6.1.0}/onlinepayments/sdk/domain/card_payment_method_specific_input.py

@@ -9,6 +9,7 @@ from .card_recurrence_details import CardRecurrenceDetails
 from .currency_conversion_input import CurrencyConversionInput
 from .data_object import DataObject
 from .multiple_payment_information import MultiplePaymentInformation
+from .network_token_data import NetworkTokenData
 from .payment_product130_specific_input import PaymentProduct130SpecificInput
 from .payment_product3012_specific_input import PaymentProduct3012SpecificInput
 from .payment_product3208_specific_input import PaymentProduct3208SpecificInput
@@ -28,6 +29,7 @@ class CardPaymentMethodSpecificInput(DataObject):
     __initial_scheme_transaction_id: Optional[str] = None
     __is_recurring: Optional[bool] = None
     __multiple_payment_information: Optional[MultiplePaymentInformation] = None
+    __network_token_data: Optional[NetworkTokenData] = None
     __payment_product130_specific_input: Optional[PaymentProduct130SpecificInput] = None
     __payment_product3012_specific_input: Optional[PaymentProduct3012SpecificInput] = None
     __payment_product3208_specific_input: Optional[PaymentProduct3208SpecificInput] = None
@@ -166,7 +168,7 @@ class CardPaymentMethodSpecificInput(DataObject):
     @property
     def is_recurring(self) -> Optional[bool]:
         """
-        * true - Indicates that the transactions is part of a scheduled recurring sequence. In addition, recurringPaymentSequenceIndicator indicates if the transaction is the first or subsequent in a recurring sequence.
+        * true - Indicates that the transaction is part of a scheduled recurring sequence. In addition, recurringPaymentSequenceIndicator indicates if the transaction is the first or subsequent in a recurring sequence.
         * false - Indicates that the transaction is not part of a scheduled recurring sequence. The default value for this property is false.
 
         Type: bool
@@ -190,6 +192,19 @@ class CardPaymentMethodSpecificInput(DataObject):
     def multiple_payment_information(self, value: Optional[MultiplePaymentInformation]) -> None:
         self.__multiple_payment_information = value
 
+    @property
+    def network_token_data(self) -> Optional[NetworkTokenData]:
+        """
+        | Object containing network token details
+
+        Type: :class:`onlinepayments.sdk.domain.network_token_data.NetworkTokenData`
+        """
+        return self.__network_token_data
+
+    @network_token_data.setter
+    def network_token_data(self, value: Optional[NetworkTokenData]) -> None:
+        self.__network_token_data = value
+
     @property
     def payment_product130_specific_input(self) -> Optional[PaymentProduct130SpecificInput]:
         """
@@ -428,6 +443,8 @@ class CardPaymentMethodSpecificInput(DataObject):
             dictionary['isRecurring'] = self.is_recurring
         if self.multiple_payment_information is not None:
             dictionary['multiplePaymentInformation'] = self.multiple_payment_information.to_dictionary()
+        if self.network_token_data is not None:
+            dictionary['networkTokenData'] = self.network_token_data.to_dictionary()
         if self.payment_product130_specific_input is not None:
             dictionary['paymentProduct130SpecificInput'] = self.payment_product130_specific_input.to_dictionary()
         if self.payment_product3012_specific_input is not None:
@@ -491,6 +508,11 @@ class CardPaymentMethodSpecificInput(DataObject):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['multiplePaymentInformation']))
             value = MultiplePaymentInformation()
             self.multiple_payment_information = value.from_dictionary(dictionary['multiplePaymentInformation'])
+        if 'networkTokenData' in dictionary:
+            if not isinstance(dictionary['networkTokenData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['networkTokenData']))
+            value = NetworkTokenData()
+            self.network_token_data = value.from_dictionary(dictionary['networkTokenData'])
         if 'paymentProduct130SpecificInput' in dictionary:
             if not isinstance(dictionary['paymentProduct130SpecificInput'], dict):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct130SpecificInput']))

{onlinepayments_sdk_python3-5.1.0 → onlinepayments_sdk_python3-6.1.0}/onlinepayments/sdk/domain/card_payment_method_specific_output.py

@@ -7,6 +7,7 @@ from typing import Optional
 from .acquirer_information import AcquirerInformation
 from .card_essentials import CardEssentials
 from .card_fraud_results import CardFraudResults
+from .click_to_pay import ClickToPay
 from .currency_conversion import CurrencyConversion
 from .data_object import DataObject
 from .external_token_linked import ExternalTokenLinked
@@ -22,6 +23,7 @@ class CardPaymentMethodSpecificOutput(DataObject):
     __authenticated_amount: Optional[int] = None
     __authorisation_code: Optional[str] = None
     __card: Optional[CardEssentials] = None
+    __click_to_pay: Optional[ClickToPay] = None
     __currency_conversion: Optional[CurrencyConversion] = None
     __external_token_linked: Optional[ExternalTokenLinked] = None
     __fraud_results: Optional[CardFraudResults] = None
@@ -88,6 +90,19 @@ class CardPaymentMethodSpecificOutput(DataObject):
     def card(self, value: Optional[CardEssentials]) -> None:
         self.__card = value
 
+    @property
+    def click_to_pay(self) -> Optional[ClickToPay]:
+        """
+        | Information about whether the payment is made using Click to Pay
+
+        Type: :class:`onlinepayments.sdk.domain.click_to_pay.ClickToPay`
+        """
+        return self.__click_to_pay
+
+    @click_to_pay.setter
+    def click_to_pay(self, value: Optional[ClickToPay]) -> None:
+        self.__click_to_pay = value
+
     @property
     def currency_conversion(self) -> Optional[CurrencyConversion]:
         """
@@ -263,6 +278,8 @@ class CardPaymentMethodSpecificOutput(DataObject):
             dictionary['authorisationCode'] = self.authorisation_code
         if self.card is not None:
             dictionary['card'] = self.card.to_dictionary()
+        if self.click_to_pay is not None:
+            dictionary['clickToPay'] = self.click_to_pay.to_dictionary()
         if self.currency_conversion is not None:
             dictionary['currencyConversion'] = self.currency_conversion.to_dictionary()
         if self.external_token_linked is not None:
@@ -307,6 +324,11 @@ class CardPaymentMethodSpecificOutput(DataObject):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['card']))
             value = CardEssentials()
             self.card = value.from_dictionary(dictionary['card'])
+        if 'clickToPay' in dictionary:
+            if not isinstance(dictionary['clickToPay'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['clickToPay']))
+            value = ClickToPay()
+            self.click_to_pay = value.from_dictionary(dictionary['clickToPay'])
         if 'currencyConversion' in dictionary:
             if not isinstance(dictionary['currencyConversion'], dict):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['currencyConversion']))

onlinepayments_sdk_python3-6.1.0/onlinepayments/sdk/domain/click_to_pay.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ClickToPay(DataObject):
+
+    __is_click_to_pay_payment: Optional[bool] = None
+
+    @property
+    def is_click_to_pay_payment(self) -> Optional[bool]:
+        """
+        | A flag indicating whether the payment is made using Click to Pay
+
+        Type: bool
+        """
+        return self.__is_click_to_pay_payment
+
+    @is_click_to_pay_payment.setter
+    def is_click_to_pay_payment(self, value: Optional[bool]) -> None:
+        self.__is_click_to_pay_payment = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ClickToPay, self).to_dictionary()
+        if self.is_click_to_pay_payment is not None:
+            dictionary['IsClickToPayPayment'] = self.is_click_to_pay_payment
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ClickToPay':
+        super(ClickToPay, self).from_dictionary(dictionary)
+        if 'IsClickToPayPayment' in dictionary:
+            self.is_click_to_pay_payment = dictionary['IsClickToPayPayment']
+        return self

{onlinepayments_sdk_python3-5.1.0 → onlinepayments_sdk_python3-6.1.0}/onlinepayments/sdk/domain/create_payment_link_request.py

@@ -165,11 +165,7 @@ class CreatePaymentLinkRequest(DataObject):
         """
         | An object containing the details of the related payment input.
         |
-        | Deprecated: All properties in ``paymentLinkOrder`` are deprecated.
-        | Use corresponding values as noted below:
-        | | Property | Replacement | | - | - | | merchantReference | ``references/merchantReference`` |
-        | | amount | ``order/amountOfMoney`` |
-        | | surchargeSpecificInput | ``order/surchargeSpecificInput`` |
+        | Deprecated: All properties in ``paymentLinkOrder`` are deprecated. Use corresponding values as noted below: | Property | Replacement | | - | - | | merchantReference | ``references/merchantReference`` | | amount | ``order/amountOfMoney`` | | surchargeSpecificInput | ``order/surchargeSpecificInput`` |
 
         Type: :class:`onlinepayments.sdk.domain.payment_link_order_input.PaymentLinkOrderInput`
         """