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

onlinepayments/sdk/domain/order_references.py

@@ -0,0 +1,120 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class OrderReferences(DataObject):
+
+    __descriptor: Optional[str] = None
+    __merchant_parameters: Optional[str] = None
+    __merchant_reference: Optional[str] = None
+    __operation_group_reference: Optional[str] = None
+
+    @property
+    def descriptor(self) -> Optional[str]:
+        """
+        | Descriptive text that is used towards to customer, either during an online checkout at a third party and/or on the statement of the customer. For card transactions this is usually referred to as a Soft Descriptor. The maximum allowed length varies per card acquirer:
+        
+        * AIB - 22 characters
+        * American Express - 25 characters
+        * Atos Origin BNP - 15 characters
+        * Barclays - 25 characters
+        * Catella - 22 characters
+        * CBA - 20 characters
+        * Elavon - 25 characters
+        * First Data - 25 characters
+        * INICIS (INIPAY) - 22-30 characters
+        * JCB - 25 characters
+        * Merchant Solutions - 22-25 characters
+        * Payvision (EU & HK) - 25 characters
+        * SEB Euroline - 22 characters
+        * Sub1 Argentina - 15 characters
+        * Wells Fargo - 25 characters Note that we advise you to use 22 characters as the max length as beyond this our experience is that issuers will start to truncate. We currently also only allow per API call overrides for AIB and Barclays For alternative payment products the maximum allowed length varies per payment product:
+        * 402 e-Przelewy - 30 characters
+        * 404 INICIS - 80 characters
+        * 802 Nordea ePayment Finland - 234 characters
+        * 809 iDeal - 32 characters
+        * 836 SOFORT - 42 characters
+        * 840 PayPal - 127 characters
+        * 841 WebMoney - 175 characters
+        * 849 Yandex - 64 characters
+        * 861 Alipay - 256 characters
+        * 863 WeChat Pay - 32 characters
+        * 880 BOKU - 20 characters
+        * 8580 Qiwi - 255 characters
+        * 1504 Konbini - 80 characters All other payment products do not support a descriptor.
+
+        Type: str
+        """
+        return self.__descriptor
+
+    @descriptor.setter
+    def descriptor(self, value: Optional[str]) -> None:
+        self.__descriptor = value
+
+    @property
+    def merchant_parameters(self) -> Optional[str]:
+        """
+        | It allows you to store additional parameters for the transaction in the format you prefer (e.g.-> key-value query string, JSON, etc.) These parameters are then echoed back to you in API GET calls and Webhook notifications. This field must not contain any personal data.
+
+        Type: str
+        """
+        return self.__merchant_parameters
+
+    @merchant_parameters.setter
+    def merchant_parameters(self, value: Optional[str]) -> None:
+        self.__merchant_parameters = value
+
+    @property
+    def merchant_reference(self) -> Optional[str]:
+        """
+        | Your unique reference of the transaction that is also returned in our report files. This is almost always used for your reconciliation of our report files. It is highly recommended to provide a single MerchantReference per unique order on your side
+
+        Type: str
+        """
+        return self.__merchant_reference
+
+    @merchant_reference.setter
+    def merchant_reference(self, value: Optional[str]) -> None:
+        self.__merchant_reference = value
+
+    @property
+    def operation_group_reference(self) -> Optional[str]:
+        """
+        | An identifier for a group of transactions. This reference helps to link multiple related transactions together, facilitating easier reconciliation and tracking.
+
+        Type: str
+        """
+        return self.__operation_group_reference
+
+    @operation_group_reference.setter
+    def operation_group_reference(self, value: Optional[str]) -> None:
+        self.__operation_group_reference = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(OrderReferences, self).to_dictionary()
+        if self.descriptor is not None:
+            dictionary['descriptor'] = self.descriptor
+        if self.merchant_parameters is not None:
+            dictionary['merchantParameters'] = self.merchant_parameters
+        if self.merchant_reference is not None:
+            dictionary['merchantReference'] = self.merchant_reference
+        if self.operation_group_reference is not None:
+            dictionary['operationGroupReference'] = self.operation_group_reference
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'OrderReferences':
+        super(OrderReferences, self).from_dictionary(dictionary)
+        if 'descriptor' in dictionary:
+            self.descriptor = dictionary['descriptor']
+        if 'merchantParameters' in dictionary:
+            self.merchant_parameters = dictionary['merchantParameters']
+        if 'merchantReference' in dictionary:
+            self.merchant_reference = dictionary['merchantReference']
+        if 'operationGroupReference' in dictionary:
+            self.operation_group_reference = dictionary['operationGroupReference']
+        return self

onlinepayments/sdk/domain/order_status_output.py

@@ -0,0 +1,119 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .api_error import APIError
+from .data_object import DataObject
+
+
+class OrderStatusOutput(DataObject):
+
+    __errors: Optional[List[APIError]] = None
+    __is_cancellable: Optional[bool] = None
+    __status_category: Optional[str] = None
+    __status_code: Optional[int] = None
+    __status_code_change_date_time: Optional[str] = None
+
+    @property
+    def errors(self) -> Optional[List[APIError]]:
+        """
+        Type: list[:class:`onlinepayments.sdk.domain.api_error.APIError`]
+        """
+        return self.__errors
+
+    @errors.setter
+    def errors(self, value: Optional[List[APIError]]) -> None:
+        self.__errors = value
+
+    @property
+    def is_cancellable(self) -> Optional[bool]:
+        """
+        | Flag indicating if the payment can be cancelled
+        
+        * true
+        * false
+
+        Type: bool
+        """
+        return self.__is_cancellable
+
+    @is_cancellable.setter
+    def is_cancellable(self, value: Optional[bool]) -> None:
+        self.__is_cancellable = value
+
+    @property
+    def status_category(self) -> Optional[str]:
+        """
+        | Highlevel status of the payment, payout or refund.
+
+        Type: str
+        """
+        return self.__status_category
+
+    @status_category.setter
+    def status_category(self, value: Optional[str]) -> None:
+        self.__status_category = value
+
+    @property
+    def status_code(self) -> Optional[int]:
+        """
+        | Numeric status code of the legacy API. The value can also be found in the BackOffice and in report files.
+
+        Type: int
+        """
+        return self.__status_code
+
+    @status_code.setter
+    def status_code(self, value: Optional[int]) -> None:
+        self.__status_code = value
+
+    @property
+    def status_code_change_date_time(self) -> Optional[str]:
+        """
+        | Timestamp of the latest status change
+
+        Type: str
+        """
+        return self.__status_code_change_date_time
+
+    @status_code_change_date_time.setter
+    def status_code_change_date_time(self, value: Optional[str]) -> None:
+        self.__status_code_change_date_time = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(OrderStatusOutput, self).to_dictionary()
+        if self.errors is not None:
+            dictionary['errors'] = []
+            for element in self.errors:
+                if element is not None:
+                    dictionary['errors'].append(element.to_dictionary())
+        if self.is_cancellable is not None:
+            dictionary['isCancellable'] = self.is_cancellable
+        if self.status_category is not None:
+            dictionary['statusCategory'] = self.status_category
+        if self.status_code is not None:
+            dictionary['statusCode'] = self.status_code
+        if self.status_code_change_date_time is not None:
+            dictionary['statusCodeChangeDateTime'] = self.status_code_change_date_time
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'OrderStatusOutput':
+        super(OrderStatusOutput, self).from_dictionary(dictionary)
+        if 'errors' in dictionary:
+            if not isinstance(dictionary['errors'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['errors']))
+            self.errors = []
+            for element in dictionary['errors']:
+                value = APIError()
+                self.errors.append(value.from_dictionary(element))
+        if 'isCancellable' in dictionary:
+            self.is_cancellable = dictionary['isCancellable']
+        if 'statusCategory' in dictionary:
+            self.status_category = dictionary['statusCategory']
+        if 'statusCode' in dictionary:
+            self.status_code = dictionary['statusCode']
+        if 'statusCodeChangeDateTime' in dictionary:
+            self.status_code_change_date_time = dictionary['statusCodeChangeDateTime']
+        return self

onlinepayments/sdk/domain/order_type_information.py

@@ -0,0 +1,64 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class OrderTypeInformation(DataObject):
+
+    __purchase_type: Optional[str] = None
+    __transaction_type: Optional[str] = None
+
+    @property
+    def purchase_type(self) -> Optional[str]:
+        """
+        | Possible values are:
+        
+        * physical (tangible goods shipped to the customers)
+        * digital (digital services like ebooks, streaming...)
+
+        Type: str
+        """
+        return self.__purchase_type
+
+    @purchase_type.setter
+    def purchase_type(self, value: Optional[str]) -> None:
+        self.__purchase_type = value
+
+    @property
+    def transaction_type(self) -> Optional[str]:
+        """
+        | Identifies the type of transaction being authenticated. Possible values are:
+        
+        * purchase = The purpose of the transaction is to purchase goods or services (Default)
+        * check-acceptance = The purpose of the transaction is to accept a 'check'/'cheque'
+        * account-funding = The purpose of the transaction is to fund an account
+        * quasi-cash = The purpose of the transaction is to buy a quasi cash type product that is representative of actual cash such as money orders, traveler's checks, foreign currency, lottery tickets or casino gaming chips
+        * prepaid-activation-or-load = The purpose of the transaction is to activate or load a prepaid card
+
+        Type: str
+        """
+        return self.__transaction_type
+
+    @transaction_type.setter
+    def transaction_type(self, value: Optional[str]) -> None:
+        self.__transaction_type = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(OrderTypeInformation, self).to_dictionary()
+        if self.purchase_type is not None:
+            dictionary['purchaseType'] = self.purchase_type
+        if self.transaction_type is not None:
+            dictionary['transactionType'] = self.transaction_type
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'OrderTypeInformation':
+        super(OrderTypeInformation, self).from_dictionary(dictionary)
+        if 'purchaseType' in dictionary:
+            self.purchase_type = dictionary['purchaseType']
+        if 'transactionType' in dictionary:
+            self.transaction_type = dictionary['transactionType']
+        return self

onlinepayments/sdk/domain/other_details.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class OtherDetails(DataObject):
+
+    __meta_data: Optional[str] = None
+    __travel_data: Optional[str] = None
+
+    @property
+    def meta_data(self) -> Optional[str]:
+        """
+        | Information used by the following PaymentProducts [5300] to provide details on the item such as the color, size, etc. The field is in JSON format, with keys and values expected by the payment method at transaction creation. Please refer to the payment mean documentation.
+
+        Type: str
+        """
+        return self.__meta_data
+
+    @meta_data.setter
+    def meta_data(self, value: Optional[str]) -> None:
+        self.__meta_data = value
+
+    @property
+    def travel_data(self) -> Optional[str]:
+        """
+        | Information used by the following PaymentProducts [5110,5111,5112,5125,3104,3107,3108,3109].
+
+        Type: str
+        """
+        return self.__travel_data
+
+    @travel_data.setter
+    def travel_data(self, value: Optional[str]) -> None:
+        self.__travel_data = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(OtherDetails, self).to_dictionary()
+        if self.meta_data is not None:
+            dictionary['metaData'] = self.meta_data
+        if self.travel_data is not None:
+            dictionary['travelData'] = self.travel_data
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'OtherDetails':
+        super(OtherDetails, self).from_dictionary(dictionary)
+        if 'metaData' in dictionary:
+            self.meta_data = dictionary['metaData']
+        if 'travelData' in dictionary:
+            self.travel_data = dictionary['travelData']
+        return self

onlinepayments/sdk/domain/payment_account_on_file.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentAccountOnFile(DataObject):
+
+    __create_date: Optional[str] = None
+    __number_of_card_on_file_creation_attempts_last24_hours: Optional[int] = None
+
+    @property
+    def create_date(self) -> Optional[str]:
+        """
+        | The date (YYYYMMDD) when the payment account on file was first created.
+        |
+        | In case a token is used for the transaction we will use the creation date of the token in our system in case you leave this property empty.
+
+        Type: str
+        """
+        return self.__create_date
+
+    @create_date.setter
+    def create_date(self, value: Optional[str]) -> None:
+        self.__create_date = value
+
+    @property
+    def number_of_card_on_file_creation_attempts_last24_hours(self) -> Optional[int]:
+        """
+        | Number of attempts made to add new card to the customer account in the last 24 hours
+
+        Type: int
+        """
+        return self.__number_of_card_on_file_creation_attempts_last24_hours
+
+    @number_of_card_on_file_creation_attempts_last24_hours.setter
+    def number_of_card_on_file_creation_attempts_last24_hours(self, value: Optional[int]) -> None:
+        self.__number_of_card_on_file_creation_attempts_last24_hours = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentAccountOnFile, self).to_dictionary()
+        if self.create_date is not None:
+            dictionary['createDate'] = self.create_date
+        if self.number_of_card_on_file_creation_attempts_last24_hours is not None:
+            dictionary['numberOfCardOnFileCreationAttemptsLast24Hours'] = self.number_of_card_on_file_creation_attempts_last24_hours
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentAccountOnFile':
+        super(PaymentAccountOnFile, self).from_dictionary(dictionary)
+        if 'createDate' in dictionary:
+            self.create_date = dictionary['createDate']
+        if 'numberOfCardOnFileCreationAttemptsLast24Hours' in dictionary:
+            self.number_of_card_on_file_creation_attempts_last24_hours = dictionary['numberOfCardOnFileCreationAttemptsLast24Hours']
+        return self

onlinepayments/sdk/domain/payment_context.py

@@ -0,0 +1,77 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+
+
+class PaymentContext(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __country_code: Optional[str] = None
+    __is_recurring: Optional[bool] = None
+
+    @property
+    def amount_of_money(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__amount_of_money
+
+    @amount_of_money.setter
+    def amount_of_money(self, value: Optional[AmountOfMoney]) -> None:
+        self.__amount_of_money = value
+
+    @property
+    def country_code(self) -> Optional[str]:
+        """
+        | The country the payment takes place in
+
+        Type: str
+        """
+        return self.__country_code
+
+    @country_code.setter
+    def country_code(self, value: Optional[str]) -> None:
+        self.__country_code = value
+
+    @property
+    def is_recurring(self) -> Optional[bool]:
+        """
+        | True if the payment is recurring
+
+        Type: bool
+        """
+        return self.__is_recurring
+
+    @is_recurring.setter
+    def is_recurring(self, value: Optional[bool]) -> None:
+        self.__is_recurring = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentContext, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.is_recurring is not None:
+            dictionary['isRecurring'] = self.is_recurring
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentContext':
+        super(PaymentContext, self).from_dictionary(dictionary)
+        if 'amountOfMoney' in dictionary:
+            if not isinstance(dictionary['amountOfMoney'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amountOfMoney']))
+            value = AmountOfMoney()
+            self.amount_of_money = value.from_dictionary(dictionary['amountOfMoney'])
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'isRecurring' in dictionary:
+            self.is_recurring = dictionary['isRecurring']
+        return self

onlinepayments/sdk/domain/payment_creation_output.py

@@ -0,0 +1,94 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentCreationOutput(DataObject):
+
+    __external_reference: Optional[str] = None
+    __is_new_token: Optional[bool] = None
+    __token: Optional[str] = None
+    __tokenization_succeeded: Optional[bool] = None
+
+    @property
+    def external_reference(self) -> Optional[str]:
+        """
+        | The external reference identifier for this transaction. Data in this property will also be returned in our report files, allowing you to reconcile them
+
+        Type: str
+        """
+        return self.__external_reference
+
+    @external_reference.setter
+    def external_reference(self, value: Optional[str]) -> None:
+        self.__external_reference = value
+
+    @property
+    def is_new_token(self) -> Optional[bool]:
+        """
+        | Indicates if a new token was created
+        
+        * true - A new token was created
+        * false - A token with the same card number already exists and is returned. Please note that the existing token has not been updated. When you want to update other data then the card number, you need to update data stored in the token explicitly, as data is never updated during the creation of a token.
+
+        Type: bool
+        """
+        return self.__is_new_token
+
+    @is_new_token.setter
+    def is_new_token(self, value: Optional[bool]) -> None:
+        self.__is_new_token = value
+
+    @property
+    def token(self) -> Optional[str]:
+        """
+        | ID of the token. This property is populated when the payment was done with a token or when the payment was tokenized.
+
+        Type: str
+        """
+        return self.__token
+
+    @token.setter
+    def token(self, value: Optional[str]) -> None:
+        self.__token = value
+
+    @property
+    def tokenization_succeeded(self) -> Optional[bool]:
+        """
+        | Indicates if tokenization was successful or not. If this value is false, then the token and the isNewToken property will not be set.
+
+        Type: bool
+        """
+        return self.__tokenization_succeeded
+
+    @tokenization_succeeded.setter
+    def tokenization_succeeded(self, value: Optional[bool]) -> None:
+        self.__tokenization_succeeded = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentCreationOutput, self).to_dictionary()
+        if self.external_reference is not None:
+            dictionary['externalReference'] = self.external_reference
+        if self.is_new_token is not None:
+            dictionary['isNewToken'] = self.is_new_token
+        if self.token is not None:
+            dictionary['token'] = self.token
+        if self.tokenization_succeeded is not None:
+            dictionary['tokenizationSucceeded'] = self.tokenization_succeeded
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentCreationOutput':
+        super(PaymentCreationOutput, self).from_dictionary(dictionary)
+        if 'externalReference' in dictionary:
+            self.external_reference = dictionary['externalReference']
+        if 'isNewToken' in dictionary:
+            self.is_new_token = dictionary['isNewToken']
+        if 'token' in dictionary:
+            self.token = dictionary['token']
+        if 'tokenizationSucceeded' in dictionary:
+            self.tokenization_succeeded = dictionary['tokenizationSucceeded']
+        return self