connect-sdk-python2 4.0.0__zip → 4.1.0__zip

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

@@ -0,0 +1,144 @@
+# -*- 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.token_card import TokenCard
+from worldline.connect.sdk.v1.domain.token_e_wallet import TokenEWallet
+from worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit import TokenNonSepaDirectDebit
+from worldline.connect.sdk.v1.domain.token_sepa_direct_debit_without_creditor import TokenSepaDirectDebitWithoutCreditor
+
+
+class CreateTokenRequest(DataObject):
+
+    __card = None
+    __e_wallet = None
+    __encrypted_customer_input = None
+    __non_sepa_direct_debit = None
+    __payment_product_id = None
+    __sepa_direct_debit = None
+
+    @property
+    def card(self):
+        """
+        | Object containing card details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.token_card.TokenCard`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value):
+        self.__card = value
+
+    @property
+    def e_wallet(self):
+        """
+        | Object containing eWallet details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.token_e_wallet.TokenEWallet`
+        """
+        return self.__e_wallet
+
+    @e_wallet.setter
+    def e_wallet(self, value):
+        self.__e_wallet = value
+
+    @property
+    def encrypted_customer_input(self):
+        """
+        | Data that was encrypted client side containing all customer entered data elements like card data.
+        | Note: Because this data can only be submitted once to our system and contains encrypted card data you should not store it. As the data was captured within the context of a client session you also need to submit it to us before the session has expired.
+
+        Type: str
+        """
+        return self.__encrypted_customer_input
+
+    @encrypted_customer_input.setter
+    def encrypted_customer_input(self, value):
+        self.__encrypted_customer_input = value
+
+    @property
+    def non_sepa_direct_debit(self):
+        """
+        | Object containing non SEPA Direct Debit details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.token_non_sepa_direct_debit.TokenNonSepaDirectDebit`
+        """
+        return self.__non_sepa_direct_debit
+
+    @non_sepa_direct_debit.setter
+    def non_sepa_direct_debit(self, value):
+        self.__non_sepa_direct_debit = value
+
+    @property
+    def payment_product_id(self):
+        """
+        | Payment product identifier
+        | Please see payment products <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/paymentproducts.html> for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__payment_product_id
+
+    @payment_product_id.setter
+    def payment_product_id(self, value):
+        self.__payment_product_id = value
+
+    @property
+    def sepa_direct_debit(self):
+        """
+        | Object containing SEPA Direct Debit details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.token_sepa_direct_debit_without_creditor.TokenSepaDirectDebitWithoutCreditor`
+        """
+        return self.__sepa_direct_debit
+
+    @sepa_direct_debit.setter
+    def sepa_direct_debit(self, value):
+        self.__sepa_direct_debit = value
+
+    def to_dictionary(self):
+        dictionary = super(CreateTokenRequest, self).to_dictionary()
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        if self.e_wallet is not None:
+            dictionary['eWallet'] = self.e_wallet.to_dictionary()
+        if self.encrypted_customer_input is not None:
+            dictionary['encryptedCustomerInput'] = self.encrypted_customer_input
+        if self.non_sepa_direct_debit is not None:
+            dictionary['nonSepaDirectDebit'] = self.non_sepa_direct_debit.to_dictionary()
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        if self.sepa_direct_debit is not None:
+            dictionary['sepaDirectDebit'] = self.sepa_direct_debit.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(CreateTokenRequest, self).from_dictionary(dictionary)
+        if 'card' in dictionary:
+            if not isinstance(dictionary['card'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['card']))
+            value = TokenCard()
+            self.card = value.from_dictionary(dictionary['card'])
+        if 'eWallet' in dictionary:
+            if not isinstance(dictionary['eWallet'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['eWallet']))
+            value = TokenEWallet()
+            self.e_wallet = value.from_dictionary(dictionary['eWallet'])
+        if 'encryptedCustomerInput' in dictionary:
+            self.encrypted_customer_input = dictionary['encryptedCustomerInput']
+        if 'nonSepaDirectDebit' in dictionary:
+            if not isinstance(dictionary['nonSepaDirectDebit'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['nonSepaDirectDebit']))
+            value = TokenNonSepaDirectDebit()
+            self.non_sepa_direct_debit = value.from_dictionary(dictionary['nonSepaDirectDebit'])
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        if 'sepaDirectDebit' in dictionary:
+            if not isinstance(dictionary['sepaDirectDebit'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sepaDirectDebit']))
+            value = TokenSepaDirectDebitWithoutCreditor()
+            self.sepa_direct_debit = value.from_dictionary(dictionary['sepaDirectDebit'])
+        return self

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

@@ -0,0 +1,75 @@
+# -*- 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 CreateTokenResponse(DataObject):
+
+    __is_new_token = None
+    __original_payment_id = None
+    __token = None
+
+    @property
+    def is_new_token(self):
+        """
+        | Indicates if a new token was created
+        
+        * true - A new token was created
+        * false - A token with the same card number already exists and is returned. Please note that the existing token has not been updated. When you want to update other data then the card number, you need to use the update API call, as data is never updated during the creation of a token.
+
+        Type: bool
+        """
+        return self.__is_new_token
+
+    @is_new_token.setter
+    def is_new_token(self, value):
+        self.__is_new_token = value
+
+    @property
+    def original_payment_id(self):
+        """
+        | The initial Payment ID of the transaction from which the token has been created
+
+        Type: str
+        """
+        return self.__original_payment_id
+
+    @original_payment_id.setter
+    def original_payment_id(self, value):
+        self.__original_payment_id = value
+
+    @property
+    def token(self):
+        """
+        | ID of the token
+
+        Type: str
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value):
+        self.__token = value
+
+    def to_dictionary(self):
+        dictionary = super(CreateTokenResponse, self).to_dictionary()
+        if self.is_new_token is not None:
+            dictionary['isNewToken'] = self.is_new_token
+        if self.original_payment_id is not None:
+            dictionary['originalPaymentId'] = self.original_payment_id
+        if self.token is not None:
+            dictionary['token'] = self.token
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(CreateTokenResponse, self).from_dictionary(dictionary)
+        if 'isNewToken' in dictionary:
+            self.is_new_token = dictionary['isNewToken']
+        if 'originalPaymentId' in dictionary:
+            self.original_payment_id = dictionary['originalPaymentId']
+        if 'token' in dictionary:
+            self.token = dictionary['token']
+        return self

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

@@ -0,0 +1,199 @@
+# -*- 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.displayed_data import DisplayedData
+from worldline.connect.sdk.v1.domain.payment import Payment
+from worldline.connect.sdk.v1.domain.payment_creation_references import PaymentCreationReferences
+
+
+class CreatedPaymentOutput(DataObject):
+    """
+    | This object is used when a payment was created during a HostedCheckout. It is part of the response of a GET HostedCheckout object and contains the details of the created payment object.
+    """
+
+    __displayed_data = None
+    __is_checked_remember_me = None
+    __payment = None
+    __payment_creation_references = None
+    __payment_status_category = None
+    __tokenization_succeeded = None
+    __tokens = None
+
+    @property
+    def displayed_data(self):
+        """
+        | Object that contains the action, including the needed data, that you should perform next, like showing instruction, showing the transaction results or redirect to a third party to complete the payment
+
+        Type: :class:`worldline.connect.sdk.v1.domain.displayed_data.DisplayedData`
+        """
+        return self.__displayed_data
+
+    @displayed_data.setter
+    def displayed_data(self, value):
+        self.__displayed_data = value
+
+    @property
+    def is_checked_remember_me(self):
+        """
+        | Indicates whether the customer ticked the "Remember my details for future purchases" checkbox on the MyCheckout hosted payment pages
+
+        Type: bool
+        """
+        return self.__is_checked_remember_me
+
+    @is_checked_remember_me.setter
+    def is_checked_remember_me(self, value):
+        self.__is_checked_remember_me = value
+
+    @property
+    def payment(self):
+        """
+        | Object that holds the payment data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment.Payment`
+        """
+        return self.__payment
+
+    @payment.setter
+    def payment(self, value):
+        self.__payment = value
+
+    @property
+    def payment_creation_references(self):
+        """
+        | Object containing the created references
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_creation_references.PaymentCreationReferences`
+        """
+        return self.__payment_creation_references
+
+    @payment_creation_references.setter
+    def payment_creation_references(self, value):
+        self.__payment_creation_references = value
+
+    @property
+    def payment_status_category(self):
+        """
+        | Highlevel indication of the payment status with the following possible values:
+        
+        * REJECTED - The payment has been rejected or is in such a state that it will never become successful. This category groups the following statuses:
+        
+        * CREATED
+        * REJECTED
+        * REJECTED CAPTURE
+        * REJECTED REFUND
+        * REJECTED PAYOUT
+        * CANCELLED
+        
+        
+        * SUCCESSFUL - The payment was not (yet) rejected. Use the payment statuses to determine if it was completed, see Statuses <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/statuses.html>. This category groups the following statuses:
+        
+        * PENDING PAYMENT
+        * ACCOUNT VERIFIED
+        * PENDING FRAUD APPROVAL
+        * PENDING APPROVAL
+        * AUTHORIZATION REQUESTED
+        * CAPTURE REQUESTED
+        * REFUND REQUESTED
+        * PAYOUT REQUESTED
+        * CAPTURED
+        * PAID
+        * ACCOUNT CREDITED
+        * REVERSED
+        * CHARGEBACK_NOTIFICATION
+        * CHARGEBACKED
+        * REFUNDED
+        
+        
+        * STATUS_UNKNOWN - The status of the payment is unknown at this moment. This category groups the following statuses:
+        
+        * REDIRECTED
+        
+        
+        
+        
+        | Please see Statuses <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/statuses.html> for a full overview of possible values.
+
+        Type: str
+
+        Deprecated; Use Payment.statusOutput.statusCategory instead
+        """
+        return self.__payment_status_category
+
+    @payment_status_category.setter
+    def payment_status_category(self, value):
+        self.__payment_status_category = value
+
+    @property
+    def tokenization_succeeded(self):
+        """
+        | If the payment was attempted to be tokenized, indicates if tokenization was successful or not.
+
+        Type: bool
+        """
+        return self.__tokenization_succeeded
+
+    @tokenization_succeeded.setter
+    def tokenization_succeeded(self, value):
+        self.__tokenization_succeeded = value
+
+    @property
+    def tokens(self):
+        """
+        | This property contains the tokens that are associated with the hosted checkout session/customer. You can use the tokens listed in this list for a future checkout of the same customer.
+
+        Type: str
+        """
+        return self.__tokens
+
+    @tokens.setter
+    def tokens(self, value):
+        self.__tokens = value
+
+    def to_dictionary(self):
+        dictionary = super(CreatedPaymentOutput, self).to_dictionary()
+        if self.displayed_data is not None:
+            dictionary['displayedData'] = self.displayed_data.to_dictionary()
+        if self.is_checked_remember_me is not None:
+            dictionary['isCheckedRememberMe'] = self.is_checked_remember_me
+        if self.payment is not None:
+            dictionary['payment'] = self.payment.to_dictionary()
+        if self.payment_creation_references is not None:
+            dictionary['paymentCreationReferences'] = self.payment_creation_references.to_dictionary()
+        if self.payment_status_category is not None:
+            dictionary['paymentStatusCategory'] = self.payment_status_category
+        if self.tokenization_succeeded is not None:
+            dictionary['tokenizationSucceeded'] = self.tokenization_succeeded
+        if self.tokens is not None:
+            dictionary['tokens'] = self.tokens
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(CreatedPaymentOutput, self).from_dictionary(dictionary)
+        if 'displayedData' in dictionary:
+            if not isinstance(dictionary['displayedData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['displayedData']))
+            value = DisplayedData()
+            self.displayed_data = value.from_dictionary(dictionary['displayedData'])
+        if 'isCheckedRememberMe' in dictionary:
+            self.is_checked_remember_me = dictionary['isCheckedRememberMe']
+        if 'payment' in dictionary:
+            if not isinstance(dictionary['payment'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payment']))
+            value = Payment()
+            self.payment = value.from_dictionary(dictionary['payment'])
+        if 'paymentCreationReferences' in dictionary:
+            if not isinstance(dictionary['paymentCreationReferences'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentCreationReferences']))
+            value = PaymentCreationReferences()
+            self.payment_creation_references = value.from_dictionary(dictionary['paymentCreationReferences'])
+        if 'paymentStatusCategory' in dictionary:
+            self.payment_status_category = dictionary['paymentStatusCategory']
+        if 'tokenizationSucceeded' in dictionary:
+            self.tokenization_succeeded = dictionary['tokenizationSucceeded']
+        if 'tokens' in dictionary:
+            self.tokens = dictionary['tokens']
+        return self

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

@@ -0,0 +1,217 @@
+# -*- 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 Creditor(DataObject):
+
+    __additional_address_info = None
+    __city = None
+    __country_code = None
+    __house_number = None
+    __iban = None
+    __id = None
+    __name = None
+    __reference_party = None
+    __reference_party_id = None
+    __street = None
+    __zip = None
+
+    @property
+    def additional_address_info(self):
+        """
+        | Additional information about the creditor's address, like Suite II, Apartment 2a
+
+        Type: str
+        """
+        return self.__additional_address_info
+
+    @additional_address_info.setter
+    def additional_address_info(self, value):
+        self.__additional_address_info = value
+
+    @property
+    def city(self):
+        """
+        | City of the creditor address
+
+        Type: str
+        """
+        return self.__city
+
+    @city.setter
+    def city(self, value):
+        self.__city = value
+
+    @property
+    def country_code(self):
+        """
+        | ISO 3166-1 alpha-2 country code
+
+        Type: str
+        """
+        return self.__country_code
+
+    @country_code.setter
+    def country_code(self, value):
+        self.__country_code = value
+
+    @property
+    def house_number(self):
+        """
+        | House number of the creditor address
+
+        Type: str
+        """
+        return self.__house_number
+
+    @house_number.setter
+    def house_number(self, value):
+        self.__house_number = value
+
+    @property
+    def iban(self):
+        """
+        | Creditor IBAN number
+        | The IBAN is the International Bank Account Number. It is an internationally agreed format for the bank account number and includes the ISO country code and two check digits.
+
+        Type: str
+        """
+        return self.__iban
+
+    @iban.setter
+    def iban(self, value):
+        self.__iban = value
+
+    @property
+    def id(self):
+        """
+        | Creditor identifier
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value):
+        self.__id = value
+
+    @property
+    def name(self):
+        """
+        | Name of the collecting creditor
+
+        Type: str
+        """
+        return self.__name
+
+    @name.setter
+    def name(self, value):
+        self.__name = value
+
+    @property
+    def reference_party(self):
+        """
+        | Creditor type of the legal reference of the collecting entity
+
+        Type: str
+        """
+        return self.__reference_party
+
+    @reference_party.setter
+    def reference_party(self, value):
+        self.__reference_party = value
+
+    @property
+    def reference_party_id(self):
+        """
+        | Legal reference of the collecting creditor
+
+        Type: str
+        """
+        return self.__reference_party_id
+
+    @reference_party_id.setter
+    def reference_party_id(self, value):
+        self.__reference_party_id = value
+
+    @property
+    def street(self):
+        """
+        | Street of the creditor address
+
+        Type: str
+        """
+        return self.__street
+
+    @street.setter
+    def street(self, value):
+        self.__street = value
+
+    @property
+    def zip(self):
+        """
+        | ZIP code of the creditor address
+
+        Type: str
+        """
+        return self.__zip
+
+    @zip.setter
+    def zip(self, value):
+        self.__zip = value
+
+    def to_dictionary(self):
+        dictionary = super(Creditor, self).to_dictionary()
+        if self.additional_address_info is not None:
+            dictionary['additionalAddressInfo'] = self.additional_address_info
+        if self.city is not None:
+            dictionary['city'] = self.city
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.house_number is not None:
+            dictionary['houseNumber'] = self.house_number
+        if self.iban is not None:
+            dictionary['iban'] = self.iban
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.name is not None:
+            dictionary['name'] = self.name
+        if self.reference_party is not None:
+            dictionary['referenceParty'] = self.reference_party
+        if self.reference_party_id is not None:
+            dictionary['referencePartyId'] = self.reference_party_id
+        if self.street is not None:
+            dictionary['street'] = self.street
+        if self.zip is not None:
+            dictionary['zip'] = self.zip
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(Creditor, self).from_dictionary(dictionary)
+        if 'additionalAddressInfo' in dictionary:
+            self.additional_address_info = dictionary['additionalAddressInfo']
+        if 'city' in dictionary:
+            self.city = dictionary['city']
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'houseNumber' in dictionary:
+            self.house_number = dictionary['houseNumber']
+        if 'iban' in dictionary:
+            self.iban = dictionary['iban']
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'name' in dictionary:
+            self.name = dictionary['name']
+        if 'referenceParty' in dictionary:
+            self.reference_party = dictionary['referenceParty']
+        if 'referencePartyId' in dictionary:
+            self.reference_party_id = dictionary['referencePartyId']
+        if 'street' in dictionary:
+            self.street = dictionary['street']
+        if 'zip' in dictionary:
+            self.zip = dictionary['zip']
+        return self