connect-sdk-python2 4.0.0__zip → 4.1.0__zip

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/mobile_payment_product_session302_specific_input.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class MobilePaymentProductSession302SpecificInput(DataObject):
+
+    __display_name = None
+    __domain_name = None
+    __validation_url = None
+
+    @property
+    def display_name(self):
+        """
+        | Used as an input for the Apple Pay payment button. Provide your company name in a human readable form.
+
+        Type: str
+        """
+        return self.__display_name
+
+    @display_name.setter
+    def display_name(self, value):
+        self.__display_name = value
+
+    @property
+    def domain_name(self):
+        """
+        | Provide a fully qualified domain name of your own payment page that will be showing an Apple Pay button.
+
+        Type: str
+        """
+        return self.__domain_name
+
+    @domain_name.setter
+    def domain_name(self, value):
+        self.__domain_name = value
+
+    @property
+    def validation_url(self):
+        """
+        | Provide the validation URL that has been provided by Apple once you have started an Apple Pay session.
+
+        Type: str
+        """
+        return self.__validation_url
+
+    @validation_url.setter
+    def validation_url(self, value):
+        self.__validation_url = value
+
+    def to_dictionary(self):
+        dictionary = super(MobilePaymentProductSession302SpecificInput, self).to_dictionary()
+        if self.display_name is not None:
+            dictionary['displayName'] = self.display_name
+        if self.domain_name is not None:
+            dictionary['domainName'] = self.domain_name
+        if self.validation_url is not None:
+            dictionary['validationUrl'] = self.validation_url
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(MobilePaymentProductSession302SpecificInput, self).from_dictionary(dictionary)
+        if 'displayName' in dictionary:
+            self.display_name = dictionary['displayName']
+        if 'domainName' in dictionary:
+            self.domain_name = dictionary['domainName']
+        if 'validationUrl' in dictionary:
+            self.validation_url = dictionary['validationUrl']
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/mobile_payment_product_session302_specific_output.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class MobilePaymentProductSession302SpecificOutput(DataObject):
+
+    __session_object = None
+
+    @property
+    def session_object(self):
+        """
+        | Object containing an opaque merchant session object.
+
+        Type: str
+        """
+        return self.__session_object
+
+    @session_object.setter
+    def session_object(self, value):
+        self.__session_object = value
+
+    def to_dictionary(self):
+        dictionary = super(MobilePaymentProductSession302SpecificOutput, self).to_dictionary()
+        if self.session_object is not None:
+            dictionary['sessionObject'] = self.session_object
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(MobilePaymentProductSession302SpecificOutput, self).from_dictionary(dictionary)
+        if 'sessionObject' in dictionary:
+            self.session_object = dictionary['sessionObject']
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/mobile_three_d_secure_challenge_parameters.py

@@ -0,0 +1,90 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class MobileThreeDSecureChallengeParameters(DataObject):
+
+    __acs_reference_number = None
+    __acs_signed_content = None
+    __acs_transaction_id = None
+    __three_d_server_transaction_id = None
+
+    @property
+    def acs_reference_number(self):
+        """
+        | The unique identifier assigned by the EMVCo Secretariat upon testing and approval.
+
+        Type: str
+        """
+        return self.__acs_reference_number
+
+    @acs_reference_number.setter
+    def acs_reference_number(self, value):
+        self.__acs_reference_number = value
+
+    @property
+    def acs_signed_content(self):
+        """
+        | Contains the JWS object created by the ACS for the challenge (ARes).
+
+        Type: str
+        """
+        return self.__acs_signed_content
+
+    @acs_signed_content.setter
+    def acs_signed_content(self, value):
+        self.__acs_signed_content = value
+
+    @property
+    def acs_transaction_id(self):
+        """
+        | The ACS Transaction ID for a prior 3-D Secure authenticated transaction (for example, the first recurring transaction that was authenticated with the customer).
+
+        Type: str
+        """
+        return self.__acs_transaction_id
+
+    @acs_transaction_id.setter
+    def acs_transaction_id(self, value):
+        self.__acs_transaction_id = value
+
+    @property
+    def three_d_server_transaction_id(self):
+        """
+        | The 3-D Secure version 2 transaction ID that is used for the 3D Authentication
+
+        Type: str
+        """
+        return self.__three_d_server_transaction_id
+
+    @three_d_server_transaction_id.setter
+    def three_d_server_transaction_id(self, value):
+        self.__three_d_server_transaction_id = value
+
+    def to_dictionary(self):
+        dictionary = super(MobileThreeDSecureChallengeParameters, self).to_dictionary()
+        if self.acs_reference_number is not None:
+            dictionary['acsReferenceNumber'] = self.acs_reference_number
+        if self.acs_signed_content is not None:
+            dictionary['acsSignedContent'] = self.acs_signed_content
+        if self.acs_transaction_id is not None:
+            dictionary['acsTransactionId'] = self.acs_transaction_id
+        if self.three_d_server_transaction_id is not None:
+            dictionary['threeDServerTransactionId'] = self.three_d_server_transaction_id
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(MobileThreeDSecureChallengeParameters, self).from_dictionary(dictionary)
+        if 'acsReferenceNumber' in dictionary:
+            self.acs_reference_number = dictionary['acsReferenceNumber']
+        if 'acsSignedContent' in dictionary:
+            self.acs_signed_content = dictionary['acsSignedContent']
+        if 'acsTransactionId' in dictionary:
+            self.acs_transaction_id = dictionary['acsTransactionId']
+        if 'threeDServerTransactionId' in dictionary:
+            self.three_d_server_transaction_id = dictionary['threeDServerTransactionId']
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/non_sepa_direct_debit_payment_method_specific_input.py

@@ -0,0 +1,198 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.abstract_payment_method_specific_input import AbstractPaymentMethodSpecificInput
+from worldline.connect.sdk.v1.domain.non_sepa_direct_debit_payment_product705_specific_input import NonSepaDirectDebitPaymentProduct705SpecificInput
+from worldline.connect.sdk.v1.domain.non_sepa_direct_debit_payment_product730_specific_input import NonSepaDirectDebitPaymentProduct730SpecificInput
+
+
+class NonSepaDirectDebitPaymentMethodSpecificInput(AbstractPaymentMethodSpecificInput):
+
+    __date_collect = None
+    __direct_debit_text = None
+    __is_recurring = None
+    __payment_product705_specific_input = None
+    __payment_product730_specific_input = None
+    __recurring_payment_sequence_indicator = None
+    __requires_approval = None
+    __token = None
+    __tokenize = None
+
+    @property
+    def date_collect(self):
+        """
+        | Direct Debit payment collection date
+        | Format: YYYYMMDD
+
+        Type: str
+        """
+        return self.__date_collect
+
+    @date_collect.setter
+    def date_collect(self, value):
+        self.__date_collect = value
+
+    @property
+    def direct_debit_text(self):
+        """
+        | Descriptor intended to identify the transaction on the customer's bank statement
+
+        Type: str
+        """
+        return self.__direct_debit_text
+
+    @direct_debit_text.setter
+    def direct_debit_text(self, value):
+        self.__direct_debit_text = value
+
+    @property
+    def is_recurring(self):
+        """
+        | Indicates if this transaction is of a one-off or a recurring type
+        
+        * true - This is recurring
+        * false - This is one-off
+
+        Type: bool
+        """
+        return self.__is_recurring
+
+    @is_recurring.setter
+    def is_recurring(self, value):
+        self.__is_recurring = value
+
+    @property
+    def payment_product705_specific_input(self):
+        """
+        | Object containing UK Direct Debit specific details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.non_sepa_direct_debit_payment_product705_specific_input.NonSepaDirectDebitPaymentProduct705SpecificInput`
+        """
+        return self.__payment_product705_specific_input
+
+    @payment_product705_specific_input.setter
+    def payment_product705_specific_input(self, value):
+        self.__payment_product705_specific_input = value
+
+    @property
+    def payment_product730_specific_input(self):
+        """
+        | Object containing ACH specific details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.non_sepa_direct_debit_payment_product730_specific_input.NonSepaDirectDebitPaymentProduct730SpecificInput`
+        """
+        return self.__payment_product730_specific_input
+
+    @payment_product730_specific_input.setter
+    def payment_product730_specific_input(self, value):
+        self.__payment_product730_specific_input = value
+
+    @property
+    def recurring_payment_sequence_indicator(self):
+        """
+        * first = This transaction is the first of a series of recurring transactions
+        * recurring = This transaction is a subsequent transaction in a series of recurring transactions
+        * last = This transaction is the last transaction of a series of recurring transactions
+
+        Type: str
+        """
+        return self.__recurring_payment_sequence_indicator
+
+    @recurring_payment_sequence_indicator.setter
+    def recurring_payment_sequence_indicator(self, value):
+        self.__recurring_payment_sequence_indicator = value
+
+    @property
+    def requires_approval(self):
+        """
+        * true - The payment requires approval before the funds will be captured using the Approve payment or Capture payment API.
+        * false - The payment does not require approval, and the funds will be captured automatically.
+
+        Type: bool
+        """
+        return self.__requires_approval
+
+    @requires_approval.setter
+    def requires_approval(self, value):
+        self.__requires_approval = value
+
+    @property
+    def token(self):
+        """
+        | ID of the stored token that contains the bank account details to be debited
+
+        Type: str
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value):
+        self.__token = value
+
+    @property
+    def tokenize(self):
+        """
+        | Indicates if this transaction should be tokenized
+        
+        * true - Tokenize the transaction
+        * 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):
+        self.__tokenize = value
+
+    def to_dictionary(self):
+        dictionary = super(NonSepaDirectDebitPaymentMethodSpecificInput, self).to_dictionary()
+        if self.date_collect is not None:
+            dictionary['dateCollect'] = self.date_collect
+        if self.direct_debit_text is not None:
+            dictionary['directDebitText'] = self.direct_debit_text
+        if self.is_recurring is not None:
+            dictionary['isRecurring'] = self.is_recurring
+        if self.payment_product705_specific_input is not None:
+            dictionary['paymentProduct705SpecificInput'] = self.payment_product705_specific_input.to_dictionary()
+        if self.payment_product730_specific_input is not None:
+            dictionary['paymentProduct730SpecificInput'] = self.payment_product730_specific_input.to_dictionary()
+        if self.recurring_payment_sequence_indicator is not None:
+            dictionary['recurringPaymentSequenceIndicator'] = self.recurring_payment_sequence_indicator
+        if self.requires_approval is not None:
+            dictionary['requiresApproval'] = self.requires_approval
+        if self.token is not None:
+            dictionary['token'] = self.token
+        if self.tokenize is not None:
+            dictionary['tokenize'] = self.tokenize
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(NonSepaDirectDebitPaymentMethodSpecificInput, self).from_dictionary(dictionary)
+        if 'dateCollect' in dictionary:
+            self.date_collect = dictionary['dateCollect']
+        if 'directDebitText' in dictionary:
+            self.direct_debit_text = dictionary['directDebitText']
+        if 'isRecurring' in dictionary:
+            self.is_recurring = dictionary['isRecurring']
+        if 'paymentProduct705SpecificInput' in dictionary:
+            if not isinstance(dictionary['paymentProduct705SpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct705SpecificInput']))
+            value = NonSepaDirectDebitPaymentProduct705SpecificInput()
+            self.payment_product705_specific_input = value.from_dictionary(dictionary['paymentProduct705SpecificInput'])
+        if 'paymentProduct730SpecificInput' in dictionary:
+            if not isinstance(dictionary['paymentProduct730SpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct730SpecificInput']))
+            value = NonSepaDirectDebitPaymentProduct730SpecificInput()
+            self.payment_product730_specific_input = value.from_dictionary(dictionary['paymentProduct730SpecificInput'])
+        if 'recurringPaymentSequenceIndicator' in dictionary:
+            self.recurring_payment_sequence_indicator = dictionary['recurringPaymentSequenceIndicator']
+        if 'requiresApproval' in dictionary:
+            self.requires_approval = dictionary['requiresApproval']
+        if 'token' in dictionary:
+            self.token = dictionary['token']
+        if 'tokenize' in dictionary:
+            self.tokenize = dictionary['tokenize']
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/non_sepa_direct_debit_payment_method_specific_output.py

@@ -0,0 +1,40 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.v1.domain.abstract_payment_method_specific_output import AbstractPaymentMethodSpecificOutput
+from worldline.connect.sdk.v1.domain.fraud_results import FraudResults
+
+
+class NonSepaDirectDebitPaymentMethodSpecificOutput(AbstractPaymentMethodSpecificOutput):
+
+    __fraud_results = None
+
+    @property
+    def fraud_results(self):
+        """
+        | Object containing the results of the fraud screening
+
+        Type: :class:`worldline.connect.sdk.v1.domain.fraud_results.FraudResults`
+        """
+        return self.__fraud_results
+
+    @fraud_results.setter
+    def fraud_results(self, value):
+        self.__fraud_results = value
+
+    def to_dictionary(self):
+        dictionary = super(NonSepaDirectDebitPaymentMethodSpecificOutput, self).to_dictionary()
+        if self.fraud_results is not None:
+            dictionary['fraudResults'] = self.fraud_results.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(NonSepaDirectDebitPaymentMethodSpecificOutput, self).from_dictionary(dictionary)
+        if 'fraudResults' in dictionary:
+            if not isinstance(dictionary['fraudResults'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraudResults']))
+            value = FraudResults()
+            self.fraud_results = value.from_dictionary(dictionary['fraudResults'])
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/non_sepa_direct_debit_payment_product705_specific_input.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.bank_account_bban import BankAccountBban
+
+
+class NonSepaDirectDebitPaymentProduct705SpecificInput(DataObject):
+    """
+    | UK Direct Debit specific input fields
+    """
+
+    __authorisation_id = None
+    __bank_account_bban = None
+    __transaction_type = None
+
+    @property
+    def authorisation_id(self):
+        """
+        | Core reference number for the direct debit instruction in UK
+
+        Type: str
+        """
+        return self.__authorisation_id
+
+    @authorisation_id.setter
+    def authorisation_id(self, value):
+        self.__authorisation_id = value
+
+    @property
+    def bank_account_bban(self):
+        """
+        | Object containing account holder name and bank account information
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_bban.BankAccountBban`
+        """
+        return self.__bank_account_bban
+
+    @bank_account_bban.setter
+    def bank_account_bban(self, value):
+        self.__bank_account_bban = value
+
+    @property
+    def transaction_type(self):
+        """
+        * first-payment - First payment direct debit
+        * nth-payment - Direct Debit (n-th payment)
+        * re-presented - Re-presented direct debit (after failed attempt)
+        * final-payment - Final payment direct debit
+        * new-or-reinstated - (zero N) New or reinstated direct debit instruction
+        * cancellation - (zero C) Cancellation of direct debit instruction
+        * conversion-of-paper-DDI-to-electronic-DDI - (zero S) Conversion of paper DDI to electronic DDI (only used once, when migrating from traditional direct debit to AUDDIS
+
+        Type: str
+        """
+        return self.__transaction_type
+
+    @transaction_type.setter
+    def transaction_type(self, value):
+        self.__transaction_type = value
+
+    def to_dictionary(self):
+        dictionary = super(NonSepaDirectDebitPaymentProduct705SpecificInput, self).to_dictionary()
+        if self.authorisation_id is not None:
+            dictionary['authorisationId'] = self.authorisation_id
+        if self.bank_account_bban is not None:
+            dictionary['bankAccountBban'] = self.bank_account_bban.to_dictionary()
+        if self.transaction_type is not None:
+            dictionary['transactionType'] = self.transaction_type
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(NonSepaDirectDebitPaymentProduct705SpecificInput, self).from_dictionary(dictionary)
+        if 'authorisationId' in dictionary:
+            self.authorisation_id = dictionary['authorisationId']
+        if 'bankAccountBban' in dictionary:
+            if not isinstance(dictionary['bankAccountBban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountBban']))
+            value = BankAccountBban()
+            self.bank_account_bban = value.from_dictionary(dictionary['bankAccountBban'])
+        if 'transactionType' in dictionary:
+            self.transaction_type = dictionary['transactionType']
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/non_sepa_direct_debit_payment_product730_specific_input.py

@@ -0,0 +1,43 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.bank_account_bban import BankAccountBban
+
+
+class NonSepaDirectDebitPaymentProduct730SpecificInput(DataObject):
+    """
+    | ACH specific input fields
+    """
+
+    __bank_account_bban = None
+
+    @property
+    def bank_account_bban(self):
+        """
+        | Object containing account holder name and bank account information
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_bban.BankAccountBban`
+        """
+        return self.__bank_account_bban
+
+    @bank_account_bban.setter
+    def bank_account_bban(self, value):
+        self.__bank_account_bban = value
+
+    def to_dictionary(self):
+        dictionary = super(NonSepaDirectDebitPaymentProduct730SpecificInput, self).to_dictionary()
+        if self.bank_account_bban is not None:
+            dictionary['bankAccountBban'] = self.bank_account_bban.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(NonSepaDirectDebitPaymentProduct730SpecificInput, self).from_dictionary(dictionary)
+        if 'bankAccountBban' in dictionary:
+            if not isinstance(dictionary['bankAccountBban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountBban']))
+            value = BankAccountBban()
+            self.bank_account_bban = value.from_dictionary(dictionary['bankAccountBban'])
+        return self