onlinepayments-sdk-python3 5.0.0__zip → 6.0.0__zip

onlinepayments_sdk_python3-6.0.0/onlinepayments/sdk/domain/iin_detail.py

@@ -0,0 +1,354 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from datetime import date
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class IINDetail(DataObject):
+
+    __card_corporate_indicator: Optional[bool] = None
+    __card_effective_date: Optional[date] = None
+    __card_effective_date_indicator: Optional[bool] = None
+    __card_pan_type: Optional[str] = None
+    __card_product_code: 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
+    __is_allowed_in_context: Optional[bool] = None
+    __issuer_code: Optional[str] = None
+    __issuer_name: 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
+    __payment_product_id: Optional[int] = None
+
+    @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_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_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 is_allowed_in_context(self) -> Optional[bool]:
+        """
+        | Populated only if you submitted a payment context.
+        
+        * true - The payment product is allowed in the submitted context.
+        * false - The payment product is not allowed in the submitted context. Note that in this case, none of the brands of the card will be allowed in the submitted context.
+
+        Type: bool
+        """
+        return self.__is_allowed_in_context
+
+    @is_allowed_in_context.setter
+    def is_allowed_in_context(self, value: Optional[bool]) -> None:
+        self.__is_allowed_in_context = 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 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 payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier - Please see Products documentation for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__payment_product_id
+
+    @payment_product_id.setter
+    def payment_product_id(self, value: Optional[int]) -> None:
+        self.__payment_product_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(IINDetail, self).to_dictionary()
+        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_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_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.is_allowed_in_context is not None:
+            dictionary['isAllowedInContext'] = self.is_allowed_in_context
+        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.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.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'IINDetail':
+        super(IINDetail, self).from_dictionary(dictionary)
+        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 'cardPanType' in dictionary:
+            self.card_pan_type = dictionary['cardPanType']
+        if 'cardProductCode' in dictionary:
+            self.card_product_code = dictionary['cardProductCode']
+        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 'isAllowedInContext' in dictionary:
+            self.is_allowed_in_context = dictionary['isAllowedInContext']
+        if 'issuerCode' in dictionary:
+            self.issuer_code = dictionary['issuerCode']
+        if 'issuerName' in dictionary:
+            self.issuer_name = dictionary['issuerName']
+        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 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        return self

{onlinepayments_sdk_python3-5.0.0 → onlinepayments_sdk_python3-6.0.0}/onlinepayments/sdk/domain/merchant_action.py

@@ -8,6 +8,7 @@ from .data_object import DataObject
 from .mobile_three_d_secure_challenge_parameters import MobileThreeDSecureChallengeParameters
 from .redirect_data import RedirectData
 from .show_form_data import ShowFormData
+from .show_instructions_data import ShowInstructionsData
 
 
 class MerchantAction(DataObject):
@@ -16,6 +17,7 @@ class MerchantAction(DataObject):
     __mobile_three_d_secure_challenge_parameters: Optional[MobileThreeDSecureChallengeParameters] = None
     __redirect_data: Optional[RedirectData] = None
     __show_form_data: Optional[ShowFormData] = None
+    __show_instructions_data: Optional[ShowInstructionsData] = None
 
     @property
     def action_type(self) -> Optional[str]:
@@ -76,6 +78,19 @@ class MerchantAction(DataObject):
     def show_form_data(self, value: Optional[ShowFormData]) -> None:
         self.__show_form_data = value
 
+    @property
+    def show_instructions_data(self) -> Optional[ShowInstructionsData]:
+        """
+        | Object returned for the SHOW_INSTRUCTIONS actionType.
+
+        Type: :class:`onlinepayments.sdk.domain.show_instructions_data.ShowInstructionsData`
+        """
+        return self.__show_instructions_data
+
+    @show_instructions_data.setter
+    def show_instructions_data(self, value: Optional[ShowInstructionsData]) -> None:
+        self.__show_instructions_data = value
+
     def to_dictionary(self) -> dict:
         dictionary = super(MerchantAction, self).to_dictionary()
         if self.action_type is not None:
@@ -86,6 +101,8 @@ class MerchantAction(DataObject):
             dictionary['redirectData'] = self.redirect_data.to_dictionary()
         if self.show_form_data is not None:
             dictionary['showFormData'] = self.show_form_data.to_dictionary()
+        if self.show_instructions_data is not None:
+            dictionary['showInstructionsData'] = self.show_instructions_data.to_dictionary()
         return dictionary
 
     def from_dictionary(self, dictionary: dict) -> 'MerchantAction':
@@ -107,4 +124,9 @@ class MerchantAction(DataObject):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['showFormData']))
             value = ShowFormData()
             self.show_form_data = value.from_dictionary(dictionary['showFormData'])
+        if 'showInstructionsData' in dictionary:
+            if not isinstance(dictionary['showInstructionsData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['showInstructionsData']))
+            value = ShowInstructionsData()
+            self.show_instructions_data = value.from_dictionary(dictionary['showInstructionsData'])
         return self

{onlinepayments_sdk_python3-5.0.0 → onlinepayments_sdk_python3-6.0.0}/onlinepayments/sdk/domain/mobile_payment_method_hosted_checkout_specific_input.py

@@ -38,7 +38,7 @@ class MobilePaymentMethodHostedCheckoutSpecificInput(DataObject):
     @property
     def payment_product302_specific_input(self) -> Optional[MobilePaymentProduct302SpecificInput]:
         """
-        | Object containing information specific to Apple Pay. Required for payments with product 302.
+        | Object containing information specific to Apple Pay.
 
         Type: :class:`onlinepayments.sdk.domain.mobile_payment_product302_specific_input.MobilePaymentProduct302SpecificInput`
         """

{onlinepayments_sdk_python3-5.0.0 → onlinepayments_sdk_python3-6.0.0}/onlinepayments/sdk/domain/mobile_payment_product302_specific_input.py

@@ -15,7 +15,7 @@ class MobilePaymentProduct302SpecificInput(DataObject):
     @property
     def apple_pay_recurring_payment_request(self) -> Optional[ApplePayRecurringPaymentRequest]:
         """
-        | Object containing information specific to Apple Pay recurrung request.
+        | Object containing information specific to Apple Pay recurring request.
 
         Type: :class:`onlinepayments.sdk.domain.apple_pay_recurring_payment_request.ApplePayRecurringPaymentRequest`
         """

onlinepayments_sdk_python3-6.0.0/onlinepayments/sdk/domain/mobile_payment_product320_specific_input.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .g_pay_three_d_secure import GPayThreeDSecure
+from .product320_recurring import Product320Recurring
+
+
+class MobilePaymentProduct320SpecificInput(DataObject):
+
+    __is_recurring: Optional[bool] = None
+    __recurring: Optional[Product320Recurring] = None
+    __three_d_secure: Optional[GPayThreeDSecure] = None
+    __tokenize: Optional[bool] = None
+
+    @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.
+        * false - Indicates that the transaction is not part of a scheduled recurring sequence. The default value for this property is false. For HostedCheckout use the hostedCheckoutSpecificInput.isRecurring property instead.
+
+        Type: bool
+        """
+        return self.__is_recurring
+
+    @is_recurring.setter
+    def is_recurring(self, value: Optional[bool]) -> None:
+        self.__is_recurring = value
+
+    @property
+    def recurring(self) -> Optional[Product320Recurring]:
+        """
+        | Object containing information specific to Google Pay and recurring.
+
+        Type: :class:`onlinepayments.sdk.domain.product320_recurring.Product320Recurring`
+        """
+        return self.__recurring
+
+    @recurring.setter
+    def recurring(self, value: Optional[Product320Recurring]) -> None:
+        self.__recurring = value
+
+    @property
+    def three_d_secure(self) -> Optional[GPayThreeDSecure]:
+        """
+        | Object containing specific data regarding 3-D Secure
+
+        Type: :class:`onlinepayments.sdk.domain.g_pay_three_d_secure.GPayThreeDSecure`
+        """
+        return self.__three_d_secure
+
+    @three_d_secure.setter
+    def three_d_secure(self, value: Optional[GPayThreeDSecure]) -> None:
+        self.__three_d_secure = value
+
+    @property
+    def tokenize(self) -> Optional[bool]:
+        """
+        | Indicates if this transaction should be tokenized
+        
+        * true - Tokenize the transaction. Note that a payment on the payment platform that results in a status REDIRECTED cannot be tokenized in this way.
+        * false - Do not tokenize the transaction, unless it would be tokenized by other means such as auto-tokenization of recurring payments.
+
+        Type: bool
+        """
+        return self.__tokenize
+
+    @tokenize.setter
+    def tokenize(self, value: Optional[bool]) -> None:
+        self.__tokenize = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(MobilePaymentProduct320SpecificInput, self).to_dictionary()
+        if self.is_recurring is not None:
+            dictionary['isRecurring'] = self.is_recurring
+        if self.recurring is not None:
+            dictionary['recurring'] = self.recurring.to_dictionary()
+        if self.three_d_secure is not None:
+            dictionary['threeDSecure'] = self.three_d_secure.to_dictionary()
+        if self.tokenize is not None:
+            dictionary['tokenize'] = self.tokenize
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'MobilePaymentProduct320SpecificInput':
+        super(MobilePaymentProduct320SpecificInput, self).from_dictionary(dictionary)
+        if 'isRecurring' in dictionary:
+            self.is_recurring = dictionary['isRecurring']
+        if 'recurring' in dictionary:
+            if not isinstance(dictionary['recurring'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['recurring']))
+            value = Product320Recurring()
+            self.recurring = value.from_dictionary(dictionary['recurring'])
+        if 'threeDSecure' in dictionary:
+            if not isinstance(dictionary['threeDSecure'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['threeDSecure']))
+            value = GPayThreeDSecure()
+            self.three_d_secure = value.from_dictionary(dictionary['threeDSecure'])
+        if 'tokenize' in dictionary:
+            self.tokenize = dictionary['tokenize']
+        return self

onlinepayments_sdk_python3-6.0.0/onlinepayments/sdk/domain/network_token_data.py

@@ -0,0 +1,127 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class NetworkTokenData(DataObject):
+
+    __cardholder_name: Optional[str] = None
+    __cryptogram: Optional[str] = None
+    __eci: Optional[int] = None
+    __network_token: Optional[str] = None
+    __scheme_token_requestor_id: Optional[str] = None
+    __token_expiry_date: Optional[str] = None
+
+    @property
+    def cardholder_name(self) -> Optional[str]:
+        """
+        | The card holder's name on the card associated with the Network Token.
+
+        Type: str
+        """
+        return self.__cardholder_name
+
+    @cardholder_name.setter
+    def cardholder_name(self, value: Optional[str]) -> None:
+        self.__cardholder_name = value
+
+    @property
+    def cryptogram(self) -> Optional[str]:
+        """
+        | The Token Cryptogram is a dynamic one-time use value that is used to verify the authenticity of the transaction and the integrity of the data used in the generation of the Token Cryptogram. Visa calls this the Token Authentication Verification Value (TAVV) cryptogram.
+
+        Type: str
+        """
+        return self.__cryptogram
+
+    @cryptogram.setter
+    def cryptogram(self, value: Optional[str]) -> None:
+        self.__cryptogram = value
+
+    @property
+    def eci(self) -> Optional[int]:
+        """
+        | The Electronic Commerce Indicator you got with the Token Cryptogram.
+
+        Type: int
+        """
+        return self.__eci
+
+    @eci.setter
+    def eci(self, value: Optional[int]) -> None:
+        self.__eci = value
+
+    @property
+    def network_token(self) -> Optional[str]:
+        """
+        | Payment Token associated with the Card used for the purchase. Note: This is called Payment Token in the EMVCo documentation.
+
+        Type: str
+        """
+        return self.__network_token
+
+    @network_token.setter
+    def network_token(self, value: Optional[str]) -> None:
+        self.__network_token = value
+
+    @property
+    def scheme_token_requestor_id(self) -> Optional[str]:
+        """
+        | Identifies the Token Requestor when calling the token service provider.
+
+        Type: str
+        """
+        return self.__scheme_token_requestor_id
+
+    @scheme_token_requestor_id.setter
+    def scheme_token_requestor_id(self, value: Optional[str]) -> None:
+        self.__scheme_token_requestor_id = value
+
+    @property
+    def token_expiry_date(self) -> Optional[str]:
+        """
+        | The expiry date of the network token. Format: MMYY
+
+        Type: str
+        """
+        return self.__token_expiry_date
+
+    @token_expiry_date.setter
+    def token_expiry_date(self, value: Optional[str]) -> None:
+        self.__token_expiry_date = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(NetworkTokenData, self).to_dictionary()
+        if self.cardholder_name is not None:
+            dictionary['cardholderName'] = self.cardholder_name
+        if self.cryptogram is not None:
+            dictionary['cryptogram'] = self.cryptogram
+        if self.eci is not None:
+            dictionary['eci'] = self.eci
+        if self.network_token is not None:
+            dictionary['networkToken'] = self.network_token
+        if self.scheme_token_requestor_id is not None:
+            dictionary['schemeTokenRequestorId'] = self.scheme_token_requestor_id
+        if self.token_expiry_date is not None:
+            dictionary['tokenExpiryDate'] = self.token_expiry_date
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'NetworkTokenData':
+        super(NetworkTokenData, self).from_dictionary(dictionary)
+        if 'cardholderName' in dictionary:
+            self.cardholder_name = dictionary['cardholderName']
+        if 'cryptogram' in dictionary:
+            self.cryptogram = dictionary['cryptogram']
+        if 'eci' in dictionary:
+            self.eci = dictionary['eci']
+        if 'networkToken' in dictionary:
+            self.network_token = dictionary['networkToken']
+        if 'schemeTokenRequestorId' in dictionary:
+            self.scheme_token_requestor_id = dictionary['schemeTokenRequestorId']
+        if 'tokenExpiryDate' in dictionary:
+            self.token_expiry_date = dictionary['tokenExpiryDate']
+        return self