onlinepayments-sdk-python3 7.4.1__py3-none-any.whl

onlinepayments/sdk/domain/customer.py

@@ -0,0 +1,234 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .address import Address
+from .company_information import CompanyInformation
+from .contact_details import ContactDetails
+from .customer_account import CustomerAccount
+from .customer_device import CustomerDevice
+from .data_object import DataObject
+from .personal_information import PersonalInformation
+
+
+class Customer(DataObject):
+
+    __account: Optional[CustomerAccount] = None
+    __account_type: Optional[str] = None
+    __billing_address: Optional[Address] = None
+    __company_information: Optional[CompanyInformation] = None
+    __contact_details: Optional[ContactDetails] = None
+    __device: Optional[CustomerDevice] = None
+    __fiscal_number: Optional[str] = None
+    __locale: Optional[str] = None
+    __merchant_customer_id: Optional[str] = None
+    __personal_information: Optional[PersonalInformation] = None
+
+    @property
+    def account(self) -> Optional[CustomerAccount]:
+        """
+        | Object containing data related to the account the customer has with you
+
+        Type: :class:`onlinepayments.sdk.domain.customer_account.CustomerAccount`
+        """
+        return self.__account
+
+    @account.setter
+    def account(self, value: Optional[CustomerAccount]) -> None:
+        self.__account = value
+
+    @property
+    def account_type(self) -> Optional[str]:
+        """
+        | Type of the customer account that is used to place this order. Can have one of the following values:
+        
+        * none - The account that was used to place the order with is a guest account or no account was used at all
+        * created - The customer account was created during this transaction
+        * existing - The customer account was an already existing account prior to this transaction
+
+        Type: str
+        """
+        return self.__account_type
+
+    @account_type.setter
+    def account_type(self, value: Optional[str]) -> None:
+        self.__account_type = value
+
+    @property
+    def billing_address(self) -> Optional[Address]:
+        """
+        | Object containing billing address details.
+
+        Type: :class:`onlinepayments.sdk.domain.address.Address`
+        """
+        return self.__billing_address
+
+    @billing_address.setter
+    def billing_address(self, value: Optional[Address]) -> None:
+        self.__billing_address = value
+
+    @property
+    def company_information(self) -> Optional[CompanyInformation]:
+        """
+        | Object containing company information
+
+        Type: :class:`onlinepayments.sdk.domain.company_information.CompanyInformation`
+        """
+        return self.__company_information
+
+    @company_information.setter
+    def company_information(self, value: Optional[CompanyInformation]) -> None:
+        self.__company_information = value
+
+    @property
+    def contact_details(self) -> Optional[ContactDetails]:
+        """
+        | Object containing contact details like email address and phone number
+
+        Type: :class:`onlinepayments.sdk.domain.contact_details.ContactDetails`
+        """
+        return self.__contact_details
+
+    @contact_details.setter
+    def contact_details(self, value: Optional[ContactDetails]) -> None:
+        self.__contact_details = value
+
+    @property
+    def device(self) -> Optional[CustomerDevice]:
+        """
+        | Object containing information on the device and browser of the customer
+
+        Type: :class:`onlinepayments.sdk.domain.customer_device.CustomerDevice`
+        """
+        return self.__device
+
+    @device.setter
+    def device(self, value: Optional[CustomerDevice]) -> None:
+        self.__device = value
+
+    @property
+    def fiscal_number(self) -> Optional[str]:
+        """
+        | Fiscal registration number of the customer or the tax registration number of the company for a business customer. Please find below specifics per country:
+        
+        * Brazil - Consumer (CPF) with a length of 11 digits
+        * Brazil - Company (CNPJ) with a length of 14 digits
+        * Denmark - Consumer (CPR-nummer or personnummer) with a length of 10 digits
+        * Finland - Consumer (Finnish: henkilötunnus (abbreviated as HETU), Swedish: personbeteckning) with a length of 11 characters
+        * Norway - Consumer (fødselsnummer) with a length of 11 digits
+        * Sweden - Consumer (personnummer) with a length of 10 or 12 digits
+
+        Type: str
+        """
+        return self.__fiscal_number
+
+    @fiscal_number.setter
+    def fiscal_number(self, value: Optional[str]) -> None:
+        self.__fiscal_number = value
+
+    @property
+    def locale(self) -> Optional[str]:
+        """
+        | The locale that the customer should be addressed in (for 3rd parties). Note that some third party providers only support the languageCode part of the locale, in those cases we will only use part of the locale provided.
+
+        Type: str
+        """
+        return self.__locale
+
+    @locale.setter
+    def locale(self, value: Optional[str]) -> None:
+        self.__locale = value
+
+    @property
+    def merchant_customer_id(self) -> Optional[str]:
+        """
+        | Your identifier for the customer. It is used in the fraud-screening process for payments on the payment platform.
+
+        Type: str
+        """
+        return self.__merchant_customer_id
+
+    @merchant_customer_id.setter
+    def merchant_customer_id(self, value: Optional[str]) -> None:
+        self.__merchant_customer_id = value
+
+    @property
+    def personal_information(self) -> Optional[PersonalInformation]:
+        """
+        | Object containing personal information like name, date of birth and gender.
+
+        Type: :class:`onlinepayments.sdk.domain.personal_information.PersonalInformation`
+        """
+        return self.__personal_information
+
+    @personal_information.setter
+    def personal_information(self, value: Optional[PersonalInformation]) -> None:
+        self.__personal_information = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Customer, self).to_dictionary()
+        if self.account is not None:
+            dictionary['account'] = self.account.to_dictionary()
+        if self.account_type is not None:
+            dictionary['accountType'] = self.account_type
+        if self.billing_address is not None:
+            dictionary['billingAddress'] = self.billing_address.to_dictionary()
+        if self.company_information is not None:
+            dictionary['companyInformation'] = self.company_information.to_dictionary()
+        if self.contact_details is not None:
+            dictionary['contactDetails'] = self.contact_details.to_dictionary()
+        if self.device is not None:
+            dictionary['device'] = self.device.to_dictionary()
+        if self.fiscal_number is not None:
+            dictionary['fiscalNumber'] = self.fiscal_number
+        if self.locale is not None:
+            dictionary['locale'] = self.locale
+        if self.merchant_customer_id is not None:
+            dictionary['merchantCustomerId'] = self.merchant_customer_id
+        if self.personal_information is not None:
+            dictionary['personalInformation'] = self.personal_information.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Customer':
+        super(Customer, self).from_dictionary(dictionary)
+        if 'account' in dictionary:
+            if not isinstance(dictionary['account'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['account']))
+            value = CustomerAccount()
+            self.account = value.from_dictionary(dictionary['account'])
+        if 'accountType' in dictionary:
+            self.account_type = dictionary['accountType']
+        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 'companyInformation' in dictionary:
+            if not isinstance(dictionary['companyInformation'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['companyInformation']))
+            value = CompanyInformation()
+            self.company_information = value.from_dictionary(dictionary['companyInformation'])
+        if 'contactDetails' in dictionary:
+            if not isinstance(dictionary['contactDetails'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['contactDetails']))
+            value = ContactDetails()
+            self.contact_details = value.from_dictionary(dictionary['contactDetails'])
+        if 'device' in dictionary:
+            if not isinstance(dictionary['device'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['device']))
+            value = CustomerDevice()
+            self.device = value.from_dictionary(dictionary['device'])
+        if 'fiscalNumber' in dictionary:
+            self.fiscal_number = dictionary['fiscalNumber']
+        if 'locale' in dictionary:
+            self.locale = dictionary['locale']
+        if 'merchantCustomerId' in dictionary:
+            self.merchant_customer_id = dictionary['merchantCustomerId']
+        if 'personalInformation' in dictionary:
+            if not isinstance(dictionary['personalInformation'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['personalInformation']))
+            value = PersonalInformation()
+            self.personal_information = value.from_dictionary(dictionary['personalInformation'])
+        return self

onlinepayments/sdk/domain/customer_account.py

@@ -0,0 +1,204 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .customer_account_authentication import CustomerAccountAuthentication
+from .customer_payment_activity import CustomerPaymentActivity
+from .data_object import DataObject
+from .payment_account_on_file import PaymentAccountOnFile
+
+
+class CustomerAccount(DataObject):
+
+    __authentication: Optional[CustomerAccountAuthentication] = None
+    __change_date: Optional[str] = None
+    __changed_during_checkout: Optional[bool] = None
+    __create_date: Optional[str] = None
+    __had_suspicious_activity: Optional[bool] = None
+    __password_change_date: Optional[str] = None
+    __password_changed_during_checkout: Optional[bool] = None
+    __payment_account_on_file: Optional[PaymentAccountOnFile] = None
+    __payment_activity: Optional[CustomerPaymentActivity] = None
+
+    @property
+    def authentication(self) -> Optional[CustomerAccountAuthentication]:
+        """
+        | Object containing data on the authentication used by the customer to access their account
+
+        Type: :class:`onlinepayments.sdk.domain.customer_account_authentication.CustomerAccountAuthentication`
+        """
+        return self.__authentication
+
+    @authentication.setter
+    def authentication(self, value: Optional[CustomerAccountAuthentication]) -> None:
+        self.__authentication = value
+
+    @property
+    def change_date(self) -> Optional[str]:
+        """
+        | The last date (YYYYMMDD) on which the customer made changes to their account with you. These are changes to billing & shipping address details, new payment account (tokens), or new users(s) added.
+
+        Type: str
+        """
+        return self.__change_date
+
+    @change_date.setter
+    def change_date(self, value: Optional[str]) -> None:
+        self.__change_date = value
+
+    @property
+    def changed_during_checkout(self) -> Optional[bool]:
+        """
+        * true = the customer made changes to their account during this checkout
+        * false = the customer did nnot change anything to their account during this checkout/n
+        
+        | The changes ment here are changes to billing & shipping address details, new payment account (tokens), or new users(s) added.
+
+        Type: bool
+        """
+        return self.__changed_during_checkout
+
+    @changed_during_checkout.setter
+    def changed_during_checkout(self, value: Optional[bool]) -> None:
+        self.__changed_during_checkout = value
+
+    @property
+    def create_date(self) -> Optional[str]:
+        """
+        | The date (YYYYMMDD) on which the customer created their account with you
+
+        Type: str
+        """
+        return self.__create_date
+
+    @create_date.setter
+    def create_date(self, value: Optional[str]) -> None:
+        self.__create_date = value
+
+    @property
+    def had_suspicious_activity(self) -> Optional[bool]:
+        """
+        | Specifies if you have experienced suspicious activity on the account of the customer
+        |
+        | true = you have experienced suspicious activity (including previous fraud) on the customer account used for this transaction
+        |
+        | false = you have experienced no suspicious activity (including previous fraud) on the customer account used for this transaction
+
+        Type: bool
+        """
+        return self.__had_suspicious_activity
+
+    @had_suspicious_activity.setter
+    def had_suspicious_activity(self, value: Optional[bool]) -> None:
+        self.__had_suspicious_activity = value
+
+    @property
+    def password_change_date(self) -> Optional[str]:
+        """
+        | The last date (YYYYMMDD) on which the customer changed their password for the account used in this transaction
+
+        Type: str
+        """
+        return self.__password_change_date
+
+    @password_change_date.setter
+    def password_change_date(self, value: Optional[str]) -> None:
+        self.__password_change_date = value
+
+    @property
+    def password_changed_during_checkout(self) -> Optional[bool]:
+        """
+        | Indicates if the password of an account is changed during this checkout
+        |
+        | true = the customer made changes to their password of the account used during this checkout
+        |
+        | false = the customer did not change anything to their password of the account used during this checkout
+
+        Type: bool
+        """
+        return self.__password_changed_during_checkout
+
+    @password_changed_during_checkout.setter
+    def password_changed_during_checkout(self, value: Optional[bool]) -> None:
+        self.__password_changed_during_checkout = value
+
+    @property
+    def payment_account_on_file(self) -> Optional[PaymentAccountOnFile]:
+        """
+        | Object containing information on the payment account data on file (tokens)
+
+        Type: :class:`onlinepayments.sdk.domain.payment_account_on_file.PaymentAccountOnFile`
+        """
+        return self.__payment_account_on_file
+
+    @payment_account_on_file.setter
+    def payment_account_on_file(self, value: Optional[PaymentAccountOnFile]) -> None:
+        self.__payment_account_on_file = value
+
+    @property
+    def payment_activity(self) -> Optional[CustomerPaymentActivity]:
+        """
+        | Object containing data on the purchase history of the customer with you
+
+        Type: :class:`onlinepayments.sdk.domain.customer_payment_activity.CustomerPaymentActivity`
+        """
+        return self.__payment_activity
+
+    @payment_activity.setter
+    def payment_activity(self, value: Optional[CustomerPaymentActivity]) -> None:
+        self.__payment_activity = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerAccount, self).to_dictionary()
+        if self.authentication is not None:
+            dictionary['authentication'] = self.authentication.to_dictionary()
+        if self.change_date is not None:
+            dictionary['changeDate'] = self.change_date
+        if self.changed_during_checkout is not None:
+            dictionary['changedDuringCheckout'] = self.changed_during_checkout
+        if self.create_date is not None:
+            dictionary['createDate'] = self.create_date
+        if self.had_suspicious_activity is not None:
+            dictionary['hadSuspiciousActivity'] = self.had_suspicious_activity
+        if self.password_change_date is not None:
+            dictionary['passwordChangeDate'] = self.password_change_date
+        if self.password_changed_during_checkout is not None:
+            dictionary['passwordChangedDuringCheckout'] = self.password_changed_during_checkout
+        if self.payment_account_on_file is not None:
+            dictionary['paymentAccountOnFile'] = self.payment_account_on_file.to_dictionary()
+        if self.payment_activity is not None:
+            dictionary['paymentActivity'] = self.payment_activity.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerAccount':
+        super(CustomerAccount, self).from_dictionary(dictionary)
+        if 'authentication' in dictionary:
+            if not isinstance(dictionary['authentication'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['authentication']))
+            value = CustomerAccountAuthentication()
+            self.authentication = value.from_dictionary(dictionary['authentication'])
+        if 'changeDate' in dictionary:
+            self.change_date = dictionary['changeDate']
+        if 'changedDuringCheckout' in dictionary:
+            self.changed_during_checkout = dictionary['changedDuringCheckout']
+        if 'createDate' in dictionary:
+            self.create_date = dictionary['createDate']
+        if 'hadSuspiciousActivity' in dictionary:
+            self.had_suspicious_activity = dictionary['hadSuspiciousActivity']
+        if 'passwordChangeDate' in dictionary:
+            self.password_change_date = dictionary['passwordChangeDate']
+        if 'passwordChangedDuringCheckout' in dictionary:
+            self.password_changed_during_checkout = dictionary['passwordChangedDuringCheckout']
+        if 'paymentAccountOnFile' in dictionary:
+            if not isinstance(dictionary['paymentAccountOnFile'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentAccountOnFile']))
+            value = PaymentAccountOnFile()
+            self.payment_account_on_file = value.from_dictionary(dictionary['paymentAccountOnFile'])
+        if 'paymentActivity' in dictionary:
+            if not isinstance(dictionary['paymentActivity'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentActivity']))
+            value = CustomerPaymentActivity()
+            self.payment_activity = value.from_dictionary(dictionary['paymentActivity'])
+        return self

onlinepayments/sdk/domain/customer_account_authentication.py

@@ -0,0 +1,81 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CustomerAccountAuthentication(DataObject):
+
+    __data: Optional[str] = None
+    __method: Optional[str] = None
+    __utc_timestamp: Optional[str] = None
+
+    @property
+    def data(self) -> Optional[str]:
+        """
+        | Data about the authentication procedure of the customer to their account with you
+
+        Type: str
+        """
+        return self.__data
+
+    @data.setter
+    def data(self, value: Optional[str]) -> None:
+        self.__data = value
+
+    @property
+    def method(self) -> Optional[str]:
+        """
+        | Authentication used by the customer on your website Possible values are
+        
+        * guest = no login occurred, customer is logged in as guest
+        * merchant-credentials = the customer logged in using credentials that are specific to you
+        * federated-id = the customer logged in using a federated ID
+        * issuer-credentials = the customer logged in using credentials from the card issuer (of the card used in this transaction)
+        * third-party-authentication = the customer logged in using third-party authentication
+        * fido-authentication = the customer logged in using a FIDO authenticator
+        * cico-b-connect-token = the customer logged in using Check-in/Check-out b.connect
+
+        Type: str
+        """
+        return self.__method
+
+    @method.setter
+    def method(self, value: Optional[str]) -> None:
+        self.__method = value
+
+    @property
+    def utc_timestamp(self) -> Optional[str]:
+        """
+        | Timestamp (YYYYMMDDHHmm) of the authentication of the customer to their account with you
+
+        Type: str
+        """
+        return self.__utc_timestamp
+
+    @utc_timestamp.setter
+    def utc_timestamp(self, value: Optional[str]) -> None:
+        self.__utc_timestamp = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerAccountAuthentication, self).to_dictionary()
+        if self.data is not None:
+            dictionary['data'] = self.data
+        if self.method is not None:
+            dictionary['method'] = self.method
+        if self.utc_timestamp is not None:
+            dictionary['utcTimestamp'] = self.utc_timestamp
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerAccountAuthentication':
+        super(CustomerAccountAuthentication, self).from_dictionary(dictionary)
+        if 'data' in dictionary:
+            self.data = dictionary['data']
+        if 'method' in dictionary:
+            self.method = dictionary['method']
+        if 'utcTimestamp' in dictionary:
+            self.utc_timestamp = dictionary['utcTimestamp']
+        return self

onlinepayments/sdk/domain/customer_bank_account.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CustomerBankAccount(DataObject):
+
+    __account_holder_name: Optional[str] = None
+    __bic: Optional[str] = None
+    __iban: Optional[str] = None
+
+    @property
+    def account_holder_name(self) -> Optional[str]:
+        """
+        | Name of account holder
+
+        Type: str
+        """
+        return self.__account_holder_name
+
+    @account_holder_name.setter
+    def account_holder_name(self, value: Optional[str]) -> None:
+        self.__account_holder_name = value
+
+    @property
+    def bic(self) -> Optional[str]:
+        """
+        | Bank Identification Code
+
+        Type: str
+        """
+        return self.__bic
+
+    @bic.setter
+    def bic(self, value: Optional[str]) -> None:
+        self.__bic = value
+
+    @property
+    def iban(self) -> Optional[str]:
+        """
+        | The IBAN is the International Bank Account Number. It is an internationally agreed format for the BBAN and includes the ISO country code and two check digits.
+
+        Type: str
+        """
+        return self.__iban
+
+    @iban.setter
+    def iban(self, value: Optional[str]) -> None:
+        self.__iban = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerBankAccount, self).to_dictionary()
+        if self.account_holder_name is not None:
+            dictionary['accountHolderName'] = self.account_holder_name
+        if self.bic is not None:
+            dictionary['bic'] = self.bic
+        if self.iban is not None:
+            dictionary['iban'] = self.iban
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerBankAccount':
+        super(CustomerBankAccount, self).from_dictionary(dictionary)
+        if 'accountHolderName' in dictionary:
+            self.account_holder_name = dictionary['accountHolderName']
+        if 'bic' in dictionary:
+            self.bic = dictionary['bic']
+        if 'iban' in dictionary:
+            self.iban = dictionary['iban']
+        return self