connect-sdk-python2 4.0.0__zip → 4.1.0__zip

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/trial_period.py

@@ -1,57 +0,0 @@
-# -*- 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 TrialPeriod(DataObject):
-    """
-    | The object containing information on the trial period duration and the interval between payments during that period.
-    """
-
-    __duration = None
-    __interval = None
-
-    @property
-    def duration(self):
-        """
-        | The number of days, weeks, months, or years before the trial period ends.
-        
-        Type: int
-        """
-        return self.__duration
-
-    @duration.setter
-    def duration(self, value):
-        self.__duration = value
-
-    @property
-    def interval(self):
-        """
-        | The interval for the trial period to finish specified as days, weeks, months, quarters, or years.
-        
-        Type: str
-        """
-        return self.__interval
-
-    @interval.setter
-    def interval(self, value):
-        self.__interval = value
-
-    def to_dictionary(self):
-        dictionary = super(TrialPeriod, self).to_dictionary()
-        if self.duration is not None:
-            dictionary['duration'] = self.duration
-        if self.interval is not None:
-            dictionary['interval'] = self.interval
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(TrialPeriod, self).from_dictionary(dictionary)
-        if 'duration' in dictionary:
-            self.duration = dictionary['duration']
-        if 'interval' in dictionary:
-            self.interval = dictionary['interval']
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/trustly_bank_account.py

@@ -1,90 +0,0 @@
-# -*- 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 TrustlyBankAccount(DataObject):
-
-    __account_last_digits = None
-    __bank_name = None
-    __clearinghouse = None
-    __person_identification_number = None
-
-    @property
-    def account_last_digits(self):
-        """
-        | The last digits of the account number
-        
-        Type: str
-        """
-        return self.__account_last_digits
-
-    @account_last_digits.setter
-    def account_last_digits(self, value):
-        self.__account_last_digits = value
-
-    @property
-    def bank_name(self):
-        """
-        | The name of the bank
-        
-        Type: str
-        """
-        return self.__bank_name
-
-    @bank_name.setter
-    def bank_name(self, value):
-        self.__bank_name = value
-
-    @property
-    def clearinghouse(self):
-        """
-        | The country of the clearing house
-        
-        Type: str
-        """
-        return self.__clearinghouse
-
-    @clearinghouse.setter
-    def clearinghouse(self, value):
-        self.__clearinghouse = value
-
-    @property
-    def person_identification_number(self):
-        """
-        | The ID number of the account holder
-        
-        Type: str
-        """
-        return self.__person_identification_number
-
-    @person_identification_number.setter
-    def person_identification_number(self, value):
-        self.__person_identification_number = value
-
-    def to_dictionary(self):
-        dictionary = super(TrustlyBankAccount, self).to_dictionary()
-        if self.account_last_digits is not None:
-            dictionary['accountLastDigits'] = self.account_last_digits
-        if self.bank_name is not None:
-            dictionary['bankName'] = self.bank_name
-        if self.clearinghouse is not None:
-            dictionary['clearinghouse'] = self.clearinghouse
-        if self.person_identification_number is not None:
-            dictionary['personIdentificationNumber'] = self.person_identification_number
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(TrustlyBankAccount, self).from_dictionary(dictionary)
-        if 'accountLastDigits' in dictionary:
-            self.account_last_digits = dictionary['accountLastDigits']
-        if 'bankName' in dictionary:
-            self.bank_name = dictionary['bankName']
-        if 'clearinghouse' in dictionary:
-            self.clearinghouse = dictionary['clearinghouse']
-        if 'personIdentificationNumber' in dictionary:
-            self.person_identification_number = dictionary['personIdentificationNumber']
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/update_token_request.py

@@ -1,125 +0,0 @@
-# -*- 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 UpdateTokenRequest(DataObject):
-
-    __card = None
-    __e_wallet = 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 non_sepa_direct_debit(self):
-        """
-        | Object containing the 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 the 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(UpdateTokenRequest, 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.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(UpdateTokenRequest, 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 '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.0.0/worldline/connect/sdk/v1/domain/upload_dispute_file_response.py

@@ -1,57 +0,0 @@
-# -*- 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 UploadDisputeFileResponse(DataObject):
-    """
-    | Response of a file upload request
-    """
-
-    __dispute_id = None
-    __file_id = None
-
-    @property
-    def dispute_id(self):
-        """
-        | Dispute ID that is associated with the created dispute.
-        
-        Type: str
-        """
-        return self.__dispute_id
-
-    @dispute_id.setter
-    def dispute_id(self, value):
-        self.__dispute_id = value
-
-    @property
-    def file_id(self):
-        """
-        | The file ID that is associated with the uploaded file. This ID can be used for further communication regarding the file and retrieval of aforementioned property.
-        
-        Type: str
-        """
-        return self.__file_id
-
-    @file_id.setter
-    def file_id(self, value):
-        self.__file_id = value
-
-    def to_dictionary(self):
-        dictionary = super(UploadDisputeFileResponse, self).to_dictionary()
-        if self.dispute_id is not None:
-            dictionary['disputeId'] = self.dispute_id
-        if self.file_id is not None:
-            dictionary['fileId'] = self.file_id
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(UploadDisputeFileResponse, self).from_dictionary(dictionary)
-        if 'disputeId' in dictionary:
-            self.dispute_id = dictionary['disputeId']
-        if 'fileId' in dictionary:
-            self.file_id = dictionary['fileId']
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/validation_bank_account_check.py

@@ -1,77 +0,0 @@
-# -*- 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 ValidationBankAccountCheck(DataObject):
-
-    __code = None
-    __description = None
-    __result = None
-
-    @property
-    def code(self):
-        """
-        | Code of the bank account validation check
-        
-        Type: str
-        """
-        return self.__code
-
-    @code.setter
-    def code(self, value):
-        self.__code = value
-
-    @property
-    def description(self):
-        """
-        | Description of check performed
-        
-        Type: str
-        """
-        return self.__description
-
-    @description.setter
-    def description(self, value):
-        self.__description = value
-
-    @property
-    def result(self):
-        """
-        | Result of the bank account validation check performed, with the following possible results:
-        
-        * PASSED - The check passed
-        * ERROR - The check did not pass
-        * WARNING - Depending on your needs this either needs to be treated as a passed or error response. It depends on your business logic and for what purpose you want to use the validated bank account details.
-        * NOTCHECKED - This check was not performed, usually because one of the earlier checks already caused an error response to be triggered
-        
-        Type: str
-        """
-        return self.__result
-
-    @result.setter
-    def result(self, value):
-        self.__result = value
-
-    def to_dictionary(self):
-        dictionary = super(ValidationBankAccountCheck, self).to_dictionary()
-        if self.code is not None:
-            dictionary['code'] = self.code
-        if self.description is not None:
-            dictionary['description'] = self.description
-        if self.result is not None:
-            dictionary['result'] = self.result
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(ValidationBankAccountCheck, self).from_dictionary(dictionary)
-        if 'code' in dictionary:
-            self.code = dictionary['code']
-        if 'description' in dictionary:
-            self.description = dictionary['description']
-        if 'result' in dictionary:
-            self.result = dictionary['result']
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/validation_bank_account_output.py

@@ -1,117 +0,0 @@
-# -*- 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.validation_bank_account_check import ValidationBankAccountCheck
-
-
-class ValidationBankAccountOutput(DataObject):
-
-    __checks = None
-    __new_bank_name = None
-    __reformatted_account_number = None
-    __reformatted_bank_code = None
-    __reformatted_branch_code = None
-
-    @property
-    def checks(self):
-        """
-        | Array of checks performed with the results of each check
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.validation_bank_account_check.ValidationBankAccountCheck`]
-        """
-        return self.__checks
-
-    @checks.setter
-    def checks(self, value):
-        self.__checks = value
-
-    @property
-    def new_bank_name(self):
-        """
-        | Bank name, matching the bank code of the request
-        
-        Type: str
-        """
-        return self.__new_bank_name
-
-    @new_bank_name.setter
-    def new_bank_name(self, value):
-        self.__new_bank_name = value
-
-    @property
-    def reformatted_account_number(self):
-        """
-        | Reformatted account number according to local clearing rules
-        
-        Type: str
-        """
-        return self.__reformatted_account_number
-
-    @reformatted_account_number.setter
-    def reformatted_account_number(self, value):
-        self.__reformatted_account_number = value
-
-    @property
-    def reformatted_bank_code(self):
-        """
-        | Reformatted bank code according to local clearing rules
-        
-        Type: str
-        """
-        return self.__reformatted_bank_code
-
-    @reformatted_bank_code.setter
-    def reformatted_bank_code(self, value):
-        self.__reformatted_bank_code = value
-
-    @property
-    def reformatted_branch_code(self):
-        """
-        | Reformatted branch code according to local clearing rules
-        
-        Type: str
-        """
-        return self.__reformatted_branch_code
-
-    @reformatted_branch_code.setter
-    def reformatted_branch_code(self, value):
-        self.__reformatted_branch_code = value
-
-    def to_dictionary(self):
-        dictionary = super(ValidationBankAccountOutput, self).to_dictionary()
-        if self.checks is not None:
-            dictionary['checks'] = []
-            for element in self.checks:
-                if element is not None:
-                    dictionary['checks'].append(element.to_dictionary())
-        if self.new_bank_name is not None:
-            dictionary['newBankName'] = self.new_bank_name
-        if self.reformatted_account_number is not None:
-            dictionary['reformattedAccountNumber'] = self.reformatted_account_number
-        if self.reformatted_bank_code is not None:
-            dictionary['reformattedBankCode'] = self.reformatted_bank_code
-        if self.reformatted_branch_code is not None:
-            dictionary['reformattedBranchCode'] = self.reformatted_branch_code
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(ValidationBankAccountOutput, self).from_dictionary(dictionary)
-        if 'checks' in dictionary:
-            if not isinstance(dictionary['checks'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['checks']))
-            self.checks = []
-            for element in dictionary['checks']:
-                value = ValidationBankAccountCheck()
-                self.checks.append(value.from_dictionary(element))
-        if 'newBankName' in dictionary:
-            self.new_bank_name = dictionary['newBankName']
-        if 'reformattedAccountNumber' in dictionary:
-            self.reformatted_account_number = dictionary['reformattedAccountNumber']
-        if 'reformattedBankCode' in dictionary:
-            self.reformatted_bank_code = dictionary['reformattedBankCode']
-        if 'reformattedBranchCode' in dictionary:
-            self.reformatted_branch_code = dictionary['reformattedBranchCode']
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/domain/value_mapping_element.py

@@ -1,83 +0,0 @@
-# -*- 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.payment_product_field_display_element import PaymentProductFieldDisplayElement
-
-
-class ValueMappingElement(DataObject):
-
-    __display_elements = None
-    __display_name = None
-    __value = None
-
-    @property
-    def display_elements(self):
-        """
-        | List of extra data of the value.
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.payment_product_field_display_element.PaymentProductFieldDisplayElement`]
-        """
-        return self.__display_elements
-
-    @display_elements.setter
-    def display_elements(self, value):
-        self.__display_elements = value
-
-    @property
-    def display_name(self):
-        """
-        | Key name
-        
-        Type: str
-        
-        Deprecated; Use displayElements instead with ID 'displayName'
-        """
-        return self.__display_name
-
-    @display_name.setter
-    def display_name(self, value):
-        self.__display_name = value
-
-    @property
-    def value(self):
-        """
-        | Value corresponding to the key
-        
-        Type: str
-        """
-        return self.__value
-
-    @value.setter
-    def value(self, value):
-        self.__value = value
-
-    def to_dictionary(self):
-        dictionary = super(ValueMappingElement, self).to_dictionary()
-        if self.display_elements is not None:
-            dictionary['displayElements'] = []
-            for element in self.display_elements:
-                if element is not None:
-                    dictionary['displayElements'].append(element.to_dictionary())
-        if self.display_name is not None:
-            dictionary['displayName'] = self.display_name
-        if self.value is not None:
-            dictionary['value'] = self.value
-        return dictionary
-
-    def from_dictionary(self, dictionary):
-        super(ValueMappingElement, self).from_dictionary(dictionary)
-        if 'displayElements' in dictionary:
-            if not isinstance(dictionary['displayElements'], list):
-                raise TypeError('value \'{}\' is not a list'.format(dictionary['displayElements']))
-            self.display_elements = []
-            for element in dictionary['displayElements']:
-                value = PaymentProductFieldDisplayElement()
-                self.display_elements.append(value.from_dictionary(element))
-        if 'displayName' in dictionary:
-            self.display_name = dictionary['displayName']
-        if 'value' in dictionary:
-            self.value = dictionary['value']
-        return self

connect-sdk-python2-4.0.0/worldline/connect/sdk/v1/exception_factory.py

@@ -1,68 +0,0 @@
-#
-# This file was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from api_exception import ApiException
-from authorization_exception import AuthorizationException
-from declined_payment_exception import DeclinedPaymentException
-from declined_payout_exception import DeclinedPayoutException
-from declined_refund_exception import DeclinedRefundException
-from idempotence_exception import IdempotenceException
-from platform_exception import PlatformException
-from reference_exception import ReferenceException
-from validation_exception import ValidationException
-from worldline.connect.sdk.v1.domain.error_response import ErrorResponse
-from worldline.connect.sdk.v1.domain.payment_error_response import PaymentErrorResponse
-from worldline.connect.sdk.v1.domain.payout_error_response import PayoutErrorResponse
-from worldline.connect.sdk.v1.domain.refund_error_response import RefundErrorResponse
-
-
-def create_exception(status_code, body, error_object, context):
-    """Return a raisable api-exception based on the error object given"""
-    def create_exception_from_errors(error_id, errors):
-        if is_idempotence_error(errors):
-            return IdempotenceException(context.idempotence_key, context.idempotence_request_timestamp,
-                                        status_code, body, error_id, errors)
-        # get error based on status code, defaulting to ApiException
-        return ERROR_MAP.get(status_code, ApiException)(status_code, body, error_id, errors)
-
-    def is_idempotence_error(errors):
-        return status_code == 409 \
-            and context is not None \
-            and context.idempotence_key is not None \
-            and len(errors) == 1 \
-            and errors[0].code
-
-    if isinstance(error_object, PaymentErrorResponse):
-        if error_object.payment_result is not None:
-            return DeclinedPaymentException(status_code=status_code,
-                                            response_body=body,
-                                            errors=error_object)
-        return create_exception_from_errors(error_object.error_id, error_object.errors)
-    if isinstance(error_object, PayoutErrorResponse):
-        if error_object.payout_result is not None:
-            return DeclinedPayoutException(status_code=status_code,
-                                           response_body=body,
-                                           errors=error_object)
-        return create_exception_from_errors(error_object.error_id, error_object.errors)
-    if isinstance(error_object, RefundErrorResponse):
-        if error_object.refund_result is not None:
-            return DeclinedRefundException(status_code=status_code,
-                                           response_body=body,
-                                           errors=error_object)
-        return create_exception_from_errors(error_object.error_id, error_object.errors)
-    if not isinstance(error_object, ErrorResponse):
-        raise ValueError("Unsupported error object encountered: {}".format(error_object.__class__.__name__))
-
-    return create_exception_from_errors(error_object.error_id, error_object.errors)
-
-
-ERROR_MAP = {
-    400: ValidationException,
-    403: AuthorizationException,
-    404: ReferenceException,
-    409: ReferenceException,  # idempotence has already been tested
-    410: ReferenceException,
-    500: PlatformException,
-    502: PlatformException,
-}