connect-sdk-python2 4.0.0__zip → 4.0.1__zip

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product771_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 PaymentProduct771SpecificOutput(DataObject):
+
+    __mandate_reference = None
+
+    @property
+    def mandate_reference(self):
+        """
+        | Unique reference to a Mandate
+
+        Type: str
+        """
+        return self.__mandate_reference
+
+    @mandate_reference.setter
+    def mandate_reference(self, value):
+        self.__mandate_reference = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProduct771SpecificOutput, self).to_dictionary()
+        if self.mandate_reference is not None:
+            dictionary['mandateReference'] = self.mandate_reference
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProduct771SpecificOutput, self).from_dictionary(dictionary)
+        if 'mandateReference' in dictionary:
+            self.mandate_reference = dictionary['mandateReference']
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product806_specific_output.py

@@ -0,0 +1,62 @@
+# -*- 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.address import Address
+from worldline.connect.sdk.v1.domain.trustly_bank_account import TrustlyBankAccount
+
+
+class PaymentProduct806SpecificOutput(DataObject):
+
+    __billing_address = None
+    __customer_account = None
+
+    @property
+    def billing_address(self):
+        """
+        | Object containing the billing address details of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.address.Address`
+        """
+        return self.__billing_address
+
+    @billing_address.setter
+    def billing_address(self, value):
+        self.__billing_address = value
+
+    @property
+    def customer_account(self):
+        """
+        | Object containing the account details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.trustly_bank_account.TrustlyBankAccount`
+        """
+        return self.__customer_account
+
+    @customer_account.setter
+    def customer_account(self, value):
+        self.__customer_account = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProduct806SpecificOutput, self).to_dictionary()
+        if self.billing_address is not None:
+            dictionary['billingAddress'] = self.billing_address.to_dictionary()
+        if self.customer_account is not None:
+            dictionary['customerAccount'] = self.customer_account.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProduct806SpecificOutput, self).from_dictionary(dictionary)
+        if 'billingAddress' in dictionary:
+            if not isinstance(dictionary['billingAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['billingAddress']))
+            value = Address()
+            self.billing_address = value.from_dictionary(dictionary['billingAddress'])
+        if 'customerAccount' in dictionary:
+            if not isinstance(dictionary['customerAccount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customerAccount']))
+            value = TrustlyBankAccount()
+            self.customer_account = value.from_dictionary(dictionary['customerAccount'])
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product836_specific_output.py

@@ -0,0 +1,39 @@
+# -*- 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 PaymentProduct836SpecificOutput(DataObject):
+
+    __security_indicator = None
+
+    @property
+    def security_indicator(self):
+        """
+        | Indicates if SofortBank could estabilish if the transaction could successfully be processed.
+        
+        * 0 - You should wait for the transaction to be reported as paid before shipping any goods.
+        * 1 - You can ship the goods. In case the transaction is not reported as paid you can initiate a claims process with SofortBank.
+
+        Type: str
+        """
+        return self.__security_indicator
+
+    @security_indicator.setter
+    def security_indicator(self, value):
+        self.__security_indicator = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProduct836SpecificOutput, self).to_dictionary()
+        if self.security_indicator is not None:
+            dictionary['securityIndicator'] = self.security_indicator
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProduct836SpecificOutput, self).from_dictionary(dictionary)
+        if 'securityIndicator' in dictionary:
+            self.security_indicator = dictionary['securityIndicator']
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product840_customer_account.py

@@ -0,0 +1,210 @@
+# -*- 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 PaymentProduct840CustomerAccount(DataObject):
+    """
+    | PayPal account details as returned by PayPal
+    """
+
+    __account_id = None
+    __billing_agreement_id = None
+    __company_name = None
+    __contact_phone = None
+    __country_code = None
+    __customer_account_status = None
+    __customer_address_status = None
+    __first_name = None
+    __payer_id = None
+    __surname = None
+
+    @property
+    def account_id(self):
+        """
+        | Username with which the PayPal account holder has registered at PayPal
+
+        Type: str
+        """
+        return self.__account_id
+
+    @account_id.setter
+    def account_id(self, value):
+        self.__account_id = value
+
+    @property
+    def billing_agreement_id(self):
+        """
+        | Identification of the PayPal recurring billing agreement
+
+        Type: str
+        """
+        return self.__billing_agreement_id
+
+    @billing_agreement_id.setter
+    def billing_agreement_id(self, value):
+        self.__billing_agreement_id = value
+
+    @property
+    def company_name(self):
+        """
+        | Name of the company in case the PayPal account is owned by a business
+
+        Type: str
+        """
+        return self.__company_name
+
+    @company_name.setter
+    def company_name(self, value):
+        self.__company_name = value
+
+    @property
+    def contact_phone(self):
+        """
+        | The phone number of the PayPal account holder
+
+        Type: str
+        """
+        return self.__contact_phone
+
+    @contact_phone.setter
+    def contact_phone(self, value):
+        self.__contact_phone = value
+
+    @property
+    def country_code(self):
+        """
+        | Country where the PayPal account is located
+
+        Type: str
+        """
+        return self.__country_code
+
+    @country_code.setter
+    def country_code(self, value):
+        self.__country_code = value
+
+    @property
+    def customer_account_status(self):
+        """
+        | Status of the PayPal account.
+        | Possible values are:
+        
+        * verified - PayPal has verified the funding means for this account
+        * unverified - PayPal has not verified the funding means for this account
+
+        Type: str
+        """
+        return self.__customer_account_status
+
+    @customer_account_status.setter
+    def customer_account_status(self, value):
+        self.__customer_account_status = value
+
+    @property
+    def customer_address_status(self):
+        """
+        | Status of the customer's shipping address as registered by PayPal
+        | Possible values are:
+        
+        * none - Status is unknown at PayPal
+        * confirmed - The address has been confirmed
+        * unconfirmed - The address has not been confirmed
+
+        Type: str
+        """
+        return self.__customer_address_status
+
+    @customer_address_status.setter
+    def customer_address_status(self, value):
+        self.__customer_address_status = value
+
+    @property
+    def first_name(self):
+        """
+        | First name of the PayPal account holder
+
+        Type: str
+        """
+        return self.__first_name
+
+    @first_name.setter
+    def first_name(self, value):
+        self.__first_name = value
+
+    @property
+    def payer_id(self):
+        """
+        | The unique identifier of a PayPal account and will never change in the life cycle of a PayPal account
+
+        Type: str
+        """
+        return self.__payer_id
+
+    @payer_id.setter
+    def payer_id(self, value):
+        self.__payer_id = value
+
+    @property
+    def surname(self):
+        """
+        | Surname of the PayPal account holder
+
+        Type: str
+        """
+        return self.__surname
+
+    @surname.setter
+    def surname(self, value):
+        self.__surname = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProduct840CustomerAccount, self).to_dictionary()
+        if self.account_id is not None:
+            dictionary['accountId'] = self.account_id
+        if self.billing_agreement_id is not None:
+            dictionary['billingAgreementId'] = self.billing_agreement_id
+        if self.company_name is not None:
+            dictionary['companyName'] = self.company_name
+        if self.contact_phone is not None:
+            dictionary['contactPhone'] = self.contact_phone
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.customer_account_status is not None:
+            dictionary['customerAccountStatus'] = self.customer_account_status
+        if self.customer_address_status is not None:
+            dictionary['customerAddressStatus'] = self.customer_address_status
+        if self.first_name is not None:
+            dictionary['firstName'] = self.first_name
+        if self.payer_id is not None:
+            dictionary['payerId'] = self.payer_id
+        if self.surname is not None:
+            dictionary['surname'] = self.surname
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProduct840CustomerAccount, self).from_dictionary(dictionary)
+        if 'accountId' in dictionary:
+            self.account_id = dictionary['accountId']
+        if 'billingAgreementId' in dictionary:
+            self.billing_agreement_id = dictionary['billingAgreementId']
+        if 'companyName' in dictionary:
+            self.company_name = dictionary['companyName']
+        if 'contactPhone' in dictionary:
+            self.contact_phone = dictionary['contactPhone']
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'customerAccountStatus' in dictionary:
+            self.customer_account_status = dictionary['customerAccountStatus']
+        if 'customerAddressStatus' in dictionary:
+            self.customer_address_status = dictionary['customerAddressStatus']
+        if 'firstName' in dictionary:
+            self.first_name = dictionary['firstName']
+        if 'payerId' in dictionary:
+            self.payer_id = dictionary['payerId']
+        if 'surname' in dictionary:
+            self.surname = dictionary['surname']
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product840_specific_output.py

@@ -0,0 +1,105 @@
+# -*- 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.address import Address
+from worldline.connect.sdk.v1.domain.payment_product840_customer_account import PaymentProduct840CustomerAccount
+from worldline.connect.sdk.v1.domain.protection_eligibility import ProtectionEligibility
+
+
+class PaymentProduct840SpecificOutput(DataObject):
+
+    __billing_address = None
+    __customer_account = None
+    __customer_address = None
+    __protection_eligibility = None
+
+    @property
+    def billing_address(self):
+        """
+        | Object containing the billing address details of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.address.Address`
+        """
+        return self.__billing_address
+
+    @billing_address.setter
+    def billing_address(self, value):
+        self.__billing_address = value
+
+    @property
+    def customer_account(self):
+        """
+        | Object containing the details of the PayPal account
+
+        Type: :class:`worldline.connect.sdk.v1.domain.payment_product840_customer_account.PaymentProduct840CustomerAccount`
+        """
+        return self.__customer_account
+
+    @customer_account.setter
+    def customer_account(self, value):
+        self.__customer_account = value
+
+    @property
+    def customer_address(self):
+        """
+        | Object containing the address details of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.address.Address`
+        """
+        return self.__customer_address
+
+    @customer_address.setter
+    def customer_address(self, value):
+        self.__customer_address = value
+
+    @property
+    def protection_eligibility(self):
+        """
+        | Protection Eligibility data of the PayPal customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.protection_eligibility.ProtectionEligibility`
+        """
+        return self.__protection_eligibility
+
+    @protection_eligibility.setter
+    def protection_eligibility(self, value):
+        self.__protection_eligibility = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProduct840SpecificOutput, self).to_dictionary()
+        if self.billing_address is not None:
+            dictionary['billingAddress'] = self.billing_address.to_dictionary()
+        if self.customer_account is not None:
+            dictionary['customerAccount'] = self.customer_account.to_dictionary()
+        if self.customer_address is not None:
+            dictionary['customerAddress'] = self.customer_address.to_dictionary()
+        if self.protection_eligibility is not None:
+            dictionary['protectionEligibility'] = self.protection_eligibility.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProduct840SpecificOutput, self).from_dictionary(dictionary)
+        if 'billingAddress' in dictionary:
+            if not isinstance(dictionary['billingAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['billingAddress']))
+            value = Address()
+            self.billing_address = value.from_dictionary(dictionary['billingAddress'])
+        if 'customerAccount' in dictionary:
+            if not isinstance(dictionary['customerAccount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customerAccount']))
+            value = PaymentProduct840CustomerAccount()
+            self.customer_account = value.from_dictionary(dictionary['customerAccount'])
+        if 'customerAddress' in dictionary:
+            if not isinstance(dictionary['customerAddress'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customerAddress']))
+            value = Address()
+            self.customer_address = value.from_dictionary(dictionary['customerAddress'])
+        if 'protectionEligibility' in dictionary:
+            if not isinstance(dictionary['protectionEligibility'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['protectionEligibility']))
+            value = ProtectionEligibility()
+            self.protection_eligibility = value.from_dictionary(dictionary['protectionEligibility'])
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product863_specific_data.py

@@ -0,0 +1,47 @@
+# -*- 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 PaymentProduct863SpecificData(DataObject):
+
+    __integration_types = None
+
+    @property
+    def integration_types(self):
+        """
+        | The WeChat Pay integration types that can be used in the current payment context. Possible values:
+        
+        * desktopQRCode - used on desktops, the customer opens the WeChat app by scanning a QR code.
+        * urlIntent - used in mobile apps or on mobile web pages, the customer opens the WeChat app using a URL intent.
+        * nativeInApp - used in mobile apps that use the WeChat Pay SDK.
+
+        Type: list[str]
+        """
+        return self.__integration_types
+
+    @integration_types.setter
+    def integration_types(self, value):
+        self.__integration_types = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProduct863SpecificData, self).to_dictionary()
+        if self.integration_types is not None:
+            dictionary['integrationTypes'] = []
+            for element in self.integration_types:
+                if element is not None:
+                    dictionary['integrationTypes'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProduct863SpecificData, self).from_dictionary(dictionary)
+        if 'integrationTypes' in dictionary:
+            if not isinstance(dictionary['integrationTypes'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['integrationTypes']))
+            self.integration_types = []
+            for element in dictionary['integrationTypes']:
+                self.integration_types.append(element)
+        return self

connect-sdk-python2-4.0.1/worldline/connect/sdk/v1/domain/payment_product863_third_party_data.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
+
+
+class PaymentProduct863ThirdPartyData(DataObject):
+
+    __app_id = None
+    __nonce_str = None
+    __package_sign = None
+    __pay_sign = None
+    __prepay_id = None
+    __sign_type = None
+    __time_stamp = None
+
+    @property
+    def app_id(self):
+        """
+        | The appId to use in third party calls to WeChat.
+
+        Type: str
+        """
+        return self.__app_id
+
+    @app_id.setter
+    def app_id(self, value):
+        self.__app_id = value
+
+    @property
+    def nonce_str(self):
+        """
+        | The nonceStr to use in third party calls to WeChat
+
+        Type: str
+        """
+        return self.__nonce_str
+
+    @nonce_str.setter
+    def nonce_str(self, value):
+        self.__nonce_str = value
+
+    @property
+    def package_sign(self):
+        """
+        | The packageSign to use in third party calls to WeChat
+
+        Type: str
+        """
+        return self.__package_sign
+
+    @package_sign.setter
+    def package_sign(self, value):
+        self.__package_sign = value
+
+    @property
+    def pay_sign(self):
+        """
+        | The paySign to use in third party calls to WeChat
+
+        Type: str
+        """
+        return self.__pay_sign
+
+    @pay_sign.setter
+    def pay_sign(self, value):
+        self.__pay_sign = value
+
+    @property
+    def prepay_id(self):
+        """
+        | The prepayId to use in third party calls to WeChat.
+
+        Type: str
+        """
+        return self.__prepay_id
+
+    @prepay_id.setter
+    def prepay_id(self, value):
+        self.__prepay_id = value
+
+    @property
+    def sign_type(self):
+        """
+        | The signType to use in third party calls to WeChat
+
+        Type: str
+        """
+        return self.__sign_type
+
+    @sign_type.setter
+    def sign_type(self, value):
+        self.__sign_type = value
+
+    @property
+    def time_stamp(self):
+        """
+        | The timeStamp to use in third party calls to WeChat
+
+        Type: str
+        """
+        return self.__time_stamp
+
+    @time_stamp.setter
+    def time_stamp(self, value):
+        self.__time_stamp = value
+
+    def to_dictionary(self):
+        dictionary = super(PaymentProduct863ThirdPartyData, self).to_dictionary()
+        if self.app_id is not None:
+            dictionary['appId'] = self.app_id
+        if self.nonce_str is not None:
+            dictionary['nonceStr'] = self.nonce_str
+        if self.package_sign is not None:
+            dictionary['packageSign'] = self.package_sign
+        if self.pay_sign is not None:
+            dictionary['paySign'] = self.pay_sign
+        if self.prepay_id is not None:
+            dictionary['prepayId'] = self.prepay_id
+        if self.sign_type is not None:
+            dictionary['signType'] = self.sign_type
+        if self.time_stamp is not None:
+            dictionary['timeStamp'] = self.time_stamp
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(PaymentProduct863ThirdPartyData, self).from_dictionary(dictionary)
+        if 'appId' in dictionary:
+            self.app_id = dictionary['appId']
+        if 'nonceStr' in dictionary:
+            self.nonce_str = dictionary['nonceStr']
+        if 'packageSign' in dictionary:
+            self.package_sign = dictionary['packageSign']
+        if 'paySign' in dictionary:
+            self.pay_sign = dictionary['paySign']
+        if 'prepayId' in dictionary:
+            self.prepay_id = dictionary['prepayId']
+        if 'signType' in dictionary:
+            self.sign_type = dictionary['signType']
+        if 'timeStamp' in dictionary:
+            self.time_stamp = dictionary['timeStamp']
+        return self