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

onlinepayments/sdk/domain/customer_device.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .browser_data import BrowserData
+from .data_object import DataObject
+
+
+class CustomerDevice(DataObject):
+
+    __accept_header: Optional[str] = None
+    __browser_data: Optional[BrowserData] = None
+    __device_fingerprint: Optional[str] = None
+    __ip_address: Optional[str] = None
+    __locale: Optional[str] = None
+    __timezone_offset_utc_minutes: Optional[str] = None
+    __user_agent: Optional[str] = None
+
+    @property
+    def accept_header(self) -> Optional[str]:
+        """
+        | The accept-header of the customer client from the HTTP Headers.
+
+        Type: str
+        """
+        return self.__accept_header
+
+    @accept_header.setter
+    def accept_header(self, value: Optional[str]) -> None:
+        self.__accept_header = value
+
+    @property
+    def browser_data(self) -> Optional[BrowserData]:
+        """
+        | Object containing information regarding the browser of the customer
+
+        Type: :class:`onlinepayments.sdk.domain.browser_data.BrowserData`
+        """
+        return self.__browser_data
+
+    @browser_data.setter
+    def browser_data(self, value: Optional[BrowserData]) -> None:
+        self.__browser_data = value
+
+    @property
+    def device_fingerprint(self) -> Optional[str]:
+        """
+        | The session ID for the device fingerprint must match the one sent in the device fingerprint script.
+
+        Type: str
+        """
+        return self.__device_fingerprint
+
+    @device_fingerprint.setter
+    def device_fingerprint(self, value: Optional[str]) -> None:
+        self.__device_fingerprint = value
+
+    @property
+    def ip_address(self) -> Optional[str]:
+        """
+        | The IP address of the customer client from the HTTP Headers.
+
+        Type: str
+        """
+        return self.__ip_address
+
+    @ip_address.setter
+    def ip_address(self, value: Optional[str]) -> None:
+        self.__ip_address = value
+
+    @property
+    def locale(self) -> Optional[str]:
+        """
+        | Locale of the client device/browser. Returned in the browser from the navigator.language property.
+        |
+        | If you use the latest version of our JavaScript Client SDK, we will collect this data and include it in the encryptedCustomerInput property. We will then automatically populate this data if available.
+
+        Type: str
+        """
+        return self.__locale
+
+    @locale.setter
+    def locale(self, value: Optional[str]) -> None:
+        self.__locale = value
+
+    @property
+    def timezone_offset_utc_minutes(self) -> Optional[str]:
+        """
+        | Offset in minutes of timezone of the client versus the UTC. Value is returned by the JavaScript getTimezoneOffset() Method.
+        |
+        | If you use the latest version of our JavaScript Client SDK, we will collect this data and include it in the encryptedCustomerInput property. We will then automatically populate this data if available.
+
+        Type: str
+        """
+        return self.__timezone_offset_utc_minutes
+
+    @timezone_offset_utc_minutes.setter
+    def timezone_offset_utc_minutes(self, value: Optional[str]) -> None:
+        self.__timezone_offset_utc_minutes = value
+
+    @property
+    def user_agent(self) -> Optional[str]:
+        """
+        | User-Agent of the client device/browser from the HTTP Headers.
+        |
+        | As a fall-back we will use the userAgent that might be included in the encryptedCustomerInput, but this is captured client side using JavaScript and might be different.
+
+        Type: str
+        """
+        return self.__user_agent
+
+    @user_agent.setter
+    def user_agent(self, value: Optional[str]) -> None:
+        self.__user_agent = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerDevice, self).to_dictionary()
+        if self.accept_header is not None:
+            dictionary['acceptHeader'] = self.accept_header
+        if self.browser_data is not None:
+            dictionary['browserData'] = self.browser_data.to_dictionary()
+        if self.device_fingerprint is not None:
+            dictionary['deviceFingerprint'] = self.device_fingerprint
+        if self.ip_address is not None:
+            dictionary['ipAddress'] = self.ip_address
+        if self.locale is not None:
+            dictionary['locale'] = self.locale
+        if self.timezone_offset_utc_minutes is not None:
+            dictionary['timezoneOffsetUtcMinutes'] = self.timezone_offset_utc_minutes
+        if self.user_agent is not None:
+            dictionary['userAgent'] = self.user_agent
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerDevice':
+        super(CustomerDevice, self).from_dictionary(dictionary)
+        if 'acceptHeader' in dictionary:
+            self.accept_header = dictionary['acceptHeader']
+        if 'browserData' in dictionary:
+            if not isinstance(dictionary['browserData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['browserData']))
+            value = BrowserData()
+            self.browser_data = value.from_dictionary(dictionary['browserData'])
+        if 'deviceFingerprint' in dictionary:
+            self.device_fingerprint = dictionary['deviceFingerprint']
+        if 'ipAddress' in dictionary:
+            self.ip_address = dictionary['ipAddress']
+        if 'locale' in dictionary:
+            self.locale = dictionary['locale']
+        if 'timezoneOffsetUtcMinutes' in dictionary:
+            self.timezone_offset_utc_minutes = dictionary['timezoneOffsetUtcMinutes']
+        if 'userAgent' in dictionary:
+            self.user_agent = dictionary['userAgent']
+        return self

onlinepayments/sdk/domain/customer_device_output.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CustomerDeviceOutput(DataObject):
+
+    __ip_address_country_code: Optional[str] = None
+
+    @property
+    def ip_address_country_code(self) -> Optional[str]:
+        """
+        | ISO 3166-1 alpha-2 country code
+
+        Type: str
+        """
+        return self.__ip_address_country_code
+
+    @ip_address_country_code.setter
+    def ip_address_country_code(self, value: Optional[str]) -> None:
+        self.__ip_address_country_code = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerDeviceOutput, self).to_dictionary()
+        if self.ip_address_country_code is not None:
+            dictionary['ipAddressCountryCode'] = self.ip_address_country_code
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerDeviceOutput':
+        super(CustomerDeviceOutput, self).from_dictionary(dictionary)
+        if 'ipAddressCountryCode' in dictionary:
+            self.ip_address_country_code = dictionary['ipAddressCountryCode']
+        return self

onlinepayments/sdk/domain/customer_output.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .customer_device_output import CustomerDeviceOutput
+from .data_object import DataObject
+
+
+class CustomerOutput(DataObject):
+
+    __device: Optional[CustomerDeviceOutput] = None
+
+    @property
+    def device(self) -> Optional[CustomerDeviceOutput]:
+        """
+        | Object containing information on the device and browser of the customer
+
+        Type: :class:`onlinepayments.sdk.domain.customer_device_output.CustomerDeviceOutput`
+        """
+        return self.__device
+
+    @device.setter
+    def device(self, value: Optional[CustomerDeviceOutput]) -> None:
+        self.__device = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerOutput, self).to_dictionary()
+        if self.device is not None:
+            dictionary['device'] = self.device.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerOutput':
+        super(CustomerOutput, self).from_dictionary(dictionary)
+        if 'device' in dictionary:
+            if not isinstance(dictionary['device'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['device']))
+            value = CustomerDeviceOutput()
+            self.device = value.from_dictionary(dictionary['device'])
+        return self

onlinepayments/sdk/domain/customer_payment_activity.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CustomerPaymentActivity(DataObject):
+
+    __number_of_payment_attempts_last24_hours: Optional[int] = None
+    __number_of_payment_attempts_last_year: Optional[int] = None
+    __number_of_purchases_last6_months: Optional[int] = None
+
+    @property
+    def number_of_payment_attempts_last24_hours(self) -> Optional[int]:
+        """
+        | Number of payment attempts (so including unsuccessful ones) made by this customer with you in the last 24 hours
+
+        Type: int
+        """
+        return self.__number_of_payment_attempts_last24_hours
+
+    @number_of_payment_attempts_last24_hours.setter
+    def number_of_payment_attempts_last24_hours(self, value: Optional[int]) -> None:
+        self.__number_of_payment_attempts_last24_hours = value
+
+    @property
+    def number_of_payment_attempts_last_year(self) -> Optional[int]:
+        """
+        | Number of payment attempts (so including unsuccessful ones) made by this customer with you in the last 12 months
+
+        Type: int
+        """
+        return self.__number_of_payment_attempts_last_year
+
+    @number_of_payment_attempts_last_year.setter
+    def number_of_payment_attempts_last_year(self, value: Optional[int]) -> None:
+        self.__number_of_payment_attempts_last_year = value
+
+    @property
+    def number_of_purchases_last6_months(self) -> Optional[int]:
+        """
+        | Number of successful purchases made by this customer with you in the last 6 months
+
+        Type: int
+        """
+        return self.__number_of_purchases_last6_months
+
+    @number_of_purchases_last6_months.setter
+    def number_of_purchases_last6_months(self, value: Optional[int]) -> None:
+        self.__number_of_purchases_last6_months = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerPaymentActivity, self).to_dictionary()
+        if self.number_of_payment_attempts_last24_hours is not None:
+            dictionary['numberOfPaymentAttemptsLast24Hours'] = self.number_of_payment_attempts_last24_hours
+        if self.number_of_payment_attempts_last_year is not None:
+            dictionary['numberOfPaymentAttemptsLastYear'] = self.number_of_payment_attempts_last_year
+        if self.number_of_purchases_last6_months is not None:
+            dictionary['numberOfPurchasesLast6Months'] = self.number_of_purchases_last6_months
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerPaymentActivity':
+        super(CustomerPaymentActivity, self).from_dictionary(dictionary)
+        if 'numberOfPaymentAttemptsLast24Hours' in dictionary:
+            self.number_of_payment_attempts_last24_hours = dictionary['numberOfPaymentAttemptsLast24Hours']
+        if 'numberOfPaymentAttemptsLastYear' in dictionary:
+            self.number_of_payment_attempts_last_year = dictionary['numberOfPaymentAttemptsLastYear']
+        if 'numberOfPurchasesLast6Months' in dictionary:
+            self.number_of_purchases_last6_months = dictionary['numberOfPurchasesLast6Months']
+        return self

onlinepayments/sdk/domain/customer_token.py

@@ -0,0 +1,83 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .address import Address
+from .company_information import CompanyInformation
+from .data_object import DataObject
+from .personal_information_token import PersonalInformationToken
+
+
+class CustomerToken(DataObject):
+
+    __billing_address: Optional[Address] = None
+    __company_information: Optional[CompanyInformation] = None
+    __personal_information: Optional[PersonalInformationToken] = None
+
+    @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 personal_information(self) -> Optional[PersonalInformationToken]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.personal_information_token.PersonalInformationToken`
+        """
+        return self.__personal_information
+
+    @personal_information.setter
+    def personal_information(self, value: Optional[PersonalInformationToken]) -> None:
+        self.__personal_information = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CustomerToken, self).to_dictionary()
+        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.personal_information is not None:
+            dictionary['personalInformation'] = self.personal_information.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CustomerToken':
+        super(CustomerToken, 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 '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 'personalInformation' in dictionary:
+            if not isinstance(dictionary['personalInformation'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['personalInformation']))
+            value = PersonalInformationToken()
+            self.personal_information = value.from_dictionary(dictionary['personalInformation'])
+        return self

onlinepayments/sdk/domain/data_object.py

@@ -0,0 +1,47 @@
+from datetime import date, datetime, timezone
+
+
+class DataObject(object):
+    def to_dictionary(self) -> dict:
+        return {}
+
+    def from_dictionary(self, dictionary: dict) -> 'DataObject':
+        if not isinstance(dictionary, dict):
+            raise TypeError('value \'{}\' is not a dictionary'.format(dictionary))
+        return self
+
+    @staticmethod
+    def parse_date(s: str) -> date:
+        return date.fromisoformat(s)
+
+    @staticmethod
+    def format_date(d: date) -> str:
+        return d.isoformat()
+
+    @staticmethod
+    def parse_datetime(s: str) -> datetime:
+        if s.endswith("Z"):
+            s = s[:-1] + "+00:00"
+
+        if "." in s:
+            main_part, fractional_and_tz = s.split(".", 1)
+
+            if "+" in fractional_and_tz:
+                fractional, tz = fractional_and_tz.split("+", 1)
+                s = "{}.{}+{}".format(main_part, fractional[:6], tz)
+            elif "-" in fractional_and_tz:
+                fractional, tz = fractional_and_tz.split("-", 1)
+                s = "{}.{}-{}".format(main_part, fractional[:6], tz)
+            else:
+                s = "{}.{}".format(main_part, fractional_and_tz[:6])
+
+        return datetime.fromisoformat(s)
+
+    @staticmethod
+    def format_datetime(dt: datetime) -> str:
+        # isoformat(timespec='milliseconds') works fine, as long as there is a timezone
+        # if there isn't one, add the current timezone
+        if dt.tzinfo is None:
+            zone = datetime.fromtimestamp(dt.timestamp(), timezone.utc).astimezone().tzinfo
+            dt = datetime.fromtimestamp(dt.timestamp(), zone)
+        return dt.isoformat(timespec='milliseconds')

onlinepayments/sdk/domain/dcc_card_source.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .card_info import CardInfo
+from .data_object import DataObject
+
+
+class DccCardSource(DataObject):
+
+    __card: Optional[CardInfo] = None
+    __encrypted_customer_input: Optional[str] = None
+    __hosted_tokenization_id: Optional[str] = None
+    __token: Optional[str] = None
+
+    @property
+    def card(self) -> Optional[CardInfo]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.card_info.CardInfo`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value: Optional[CardInfo]) -> None:
+        self.__card = value
+
+    @property
+    def encrypted_customer_input(self) -> Optional[str]:
+        """
+        | 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: Optional[str]) -> None:
+        self.__encrypted_customer_input = value
+
+    @property
+    def hosted_tokenization_id(self) -> Optional[str]:
+        """
+        | An Id of a hosted tokenization session
+
+        Type: str
+        """
+        return self.__hosted_tokenization_id
+
+    @hosted_tokenization_id.setter
+    def hosted_tokenization_id(self, value: Optional[str]) -> None:
+        self.__hosted_tokenization_id = value
+
+    @property
+    def token(self) -> Optional[str]:
+        """
+        | An identifier that represents card details that have previously been stored
+
+        Type: str
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value: Optional[str]) -> None:
+        self.__token = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(DccCardSource, self).to_dictionary()
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        if self.encrypted_customer_input is not None:
+            dictionary['encryptedCustomerInput'] = self.encrypted_customer_input
+        if self.hosted_tokenization_id is not None:
+            dictionary['hostedTokenizationId'] = self.hosted_tokenization_id
+        if self.token is not None:
+            dictionary['token'] = self.token
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'DccCardSource':
+        super(DccCardSource, 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 = CardInfo()
+            self.card = value.from_dictionary(dictionary['card'])
+        if 'encryptedCustomerInput' in dictionary:
+            self.encrypted_customer_input = dictionary['encryptedCustomerInput']
+        if 'hostedTokenizationId' in dictionary:
+            self.hosted_tokenization_id = dictionary['hostedTokenizationId']
+        if 'token' in dictionary:
+            self.token = dictionary['token']
+        return self

onlinepayments/sdk/domain/dcc_proposal.py

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+from .rate_details import RateDetails
+
+
+class DccProposal(DataObject):
+
+    __base_amount: Optional[AmountOfMoney] = None
+    __disclaimer_display: Optional[str] = None
+    __disclaimer_receipt: Optional[str] = None
+    __rate: Optional[RateDetails] = None
+    __target_amount: Optional[AmountOfMoney] = None
+
+    @property
+    def base_amount(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__base_amount
+
+    @base_amount.setter
+    def base_amount(self, value: Optional[AmountOfMoney]) -> None:
+        self.__base_amount = value
+
+    @property
+    def disclaimer_display(self) -> Optional[str]:
+        """
+        | Card scheme disclaimer to present to the cardholder
+
+        Type: str
+        """
+        return self.__disclaimer_display
+
+    @disclaimer_display.setter
+    def disclaimer_display(self, value: Optional[str]) -> None:
+        self.__disclaimer_display = value
+
+    @property
+    def disclaimer_receipt(self) -> Optional[str]:
+        """
+        | Card scheme disclaimer to print within cardholder receipt
+
+        Type: str
+        """
+        return self.__disclaimer_receipt
+
+    @disclaimer_receipt.setter
+    def disclaimer_receipt(self, value: Optional[str]) -> None:
+        self.__disclaimer_receipt = value
+
+    @property
+    def rate(self) -> Optional[RateDetails]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.rate_details.RateDetails`
+        """
+        return self.__rate
+
+    @rate.setter
+    def rate(self, value: Optional[RateDetails]) -> None:
+        self.__rate = value
+
+    @property
+    def target_amount(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__target_amount
+
+    @target_amount.setter
+    def target_amount(self, value: Optional[AmountOfMoney]) -> None:
+        self.__target_amount = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(DccProposal, self).to_dictionary()
+        if self.base_amount is not None:
+            dictionary['baseAmount'] = self.base_amount.to_dictionary()
+        if self.disclaimer_display is not None:
+            dictionary['disclaimerDisplay'] = self.disclaimer_display
+        if self.disclaimer_receipt is not None:
+            dictionary['disclaimerReceipt'] = self.disclaimer_receipt
+        if self.rate is not None:
+            dictionary['rate'] = self.rate.to_dictionary()
+        if self.target_amount is not None:
+            dictionary['targetAmount'] = self.target_amount.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'DccProposal':
+        super(DccProposal, self).from_dictionary(dictionary)
+        if 'baseAmount' in dictionary:
+            if not isinstance(dictionary['baseAmount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['baseAmount']))
+            value = AmountOfMoney()
+            self.base_amount = value.from_dictionary(dictionary['baseAmount'])
+        if 'disclaimerDisplay' in dictionary:
+            self.disclaimer_display = dictionary['disclaimerDisplay']
+        if 'disclaimerReceipt' in dictionary:
+            self.disclaimer_receipt = dictionary['disclaimerReceipt']
+        if 'rate' in dictionary:
+            if not isinstance(dictionary['rate'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['rate']))
+            value = RateDetails()
+            self.rate = value.from_dictionary(dictionary['rate'])
+        if 'targetAmount' in dictionary:
+            if not isinstance(dictionary['targetAmount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['targetAmount']))
+            value = AmountOfMoney()
+            self.target_amount = value.from_dictionary(dictionary['targetAmount'])
+        return self