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

onlinepayments/sdk/domain/card_source.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .surcharge_calculation_card import SurchargeCalculationCard
+
+
+class CardSource(DataObject):
+
+    __card: Optional[SurchargeCalculationCard] = None
+    __encrypted_customer_input: Optional[str] = None
+    __hosted_tokenization_id: Optional[str] = None
+    __token: Optional[str] = None
+
+    @property
+    def card(self) -> Optional[SurchargeCalculationCard]:
+        """
+        | An object containing card number and payment product id, which is used to determine surcharge product type
+
+        Type: :class:`onlinepayments.sdk.domain.surcharge_calculation_card.SurchargeCalculationCard`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value: Optional[SurchargeCalculationCard]) -> 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 been previously 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(CardSource, 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) -> 'CardSource':
+        super(CardSource, 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 = SurchargeCalculationCard()
+            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/card_without_cvv.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CardWithoutCvv(DataObject):
+
+    __card_number: Optional[str] = None
+    __cardholder_name: Optional[str] = None
+    __expiry_date: Optional[str] = None
+
+    @property
+    def card_number(self) -> Optional[str]:
+        """
+        | The obfuscated card number
+
+        Type: str
+        """
+        return self.__card_number
+
+    @card_number.setter
+    def card_number(self, value: Optional[str]) -> None:
+        self.__card_number = value
+
+    @property
+    def cardholder_name(self) -> Optional[str]:
+        """
+        | The card holder's name on the card.
+
+        Type: str
+        """
+        return self.__cardholder_name
+
+    @cardholder_name.setter
+    def cardholder_name(self, value: Optional[str]) -> None:
+        self.__cardholder_name = value
+
+    @property
+    def expiry_date(self) -> Optional[str]:
+        """
+        | Expiry date of the card Format: MMYY
+
+        Type: str
+        """
+        return self.__expiry_date
+
+    @expiry_date.setter
+    def expiry_date(self, value: Optional[str]) -> None:
+        self.__expiry_date = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CardWithoutCvv, self).to_dictionary()
+        if self.card_number is not None:
+            dictionary['cardNumber'] = self.card_number
+        if self.cardholder_name is not None:
+            dictionary['cardholderName'] = self.cardholder_name
+        if self.expiry_date is not None:
+            dictionary['expiryDate'] = self.expiry_date
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CardWithoutCvv':
+        super(CardWithoutCvv, self).from_dictionary(dictionary)
+        if 'cardNumber' in dictionary:
+            self.card_number = dictionary['cardNumber']
+        if 'cardholderName' in dictionary:
+            self.cardholder_name = dictionary['cardholderName']
+        if 'expiryDate' in dictionary:
+            self.expiry_date = dictionary['expiryDate']
+        return self

onlinepayments/sdk/domain/click_to_pay.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ClickToPay(DataObject):
+
+    __is_click_to_pay_payment: Optional[bool] = None
+
+    @property
+    def is_click_to_pay_payment(self) -> Optional[bool]:
+        """
+        | A flag indicating whether the payment is made using Click to Pay
+
+        Type: bool
+        """
+        return self.__is_click_to_pay_payment
+
+    @is_click_to_pay_payment.setter
+    def is_click_to_pay_payment(self, value: Optional[bool]) -> None:
+        self.__is_click_to_pay_payment = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ClickToPay, self).to_dictionary()
+        if self.is_click_to_pay_payment is not None:
+            dictionary['IsClickToPayPayment'] = self.is_click_to_pay_payment
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ClickToPay':
+        super(ClickToPay, self).from_dictionary(dictionary)
+        if 'IsClickToPayPayment' in dictionary:
+            self.is_click_to_pay_payment = dictionary['IsClickToPayPayment']
+        return self

onlinepayments/sdk/domain/company_information.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CompanyInformation(DataObject):
+
+    __name: Optional[str] = None
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        | Name of company, as a customer. For Klarna payment method, company name should be provided to trigger a B2B session. If nothing is provided, a B2C session will be the default.
+
+        Type: str
+        """
+        return self.__name
+
+    @name.setter
+    def name(self, value: Optional[str]) -> None:
+        self.__name = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CompanyInformation, self).to_dictionary()
+        if self.name is not None:
+            dictionary['name'] = self.name
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CompanyInformation':
+        super(CompanyInformation, self).from_dictionary(dictionary)
+        if 'name' in dictionary:
+            self.name = dictionary['name']
+        return self

onlinepayments/sdk/domain/complete_payment_card_payment_method_specific_input.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .card_without_cvv import CardWithoutCvv
+from .data_object import DataObject
+
+
+class CompletePaymentCardPaymentMethodSpecificInput(DataObject):
+
+    __card: Optional[CardWithoutCvv] = None
+
+    @property
+    def card(self) -> Optional[CardWithoutCvv]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.card_without_cvv.CardWithoutCvv`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value: Optional[CardWithoutCvv]) -> None:
+        self.__card = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CompletePaymentCardPaymentMethodSpecificInput, self).to_dictionary()
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CompletePaymentCardPaymentMethodSpecificInput':
+        super(CompletePaymentCardPaymentMethodSpecificInput, 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 = CardWithoutCvv()
+            self.card = value.from_dictionary(dictionary['card'])
+        return self

onlinepayments/sdk/domain/complete_payment_request.py

@@ -0,0 +1,61 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .complete_payment_card_payment_method_specific_input import CompletePaymentCardPaymentMethodSpecificInput
+from .data_object import DataObject
+from .order import Order
+
+
+class CompletePaymentRequest(DataObject):
+
+    __card_payment_method_specific_input: Optional[CompletePaymentCardPaymentMethodSpecificInput] = None
+    __order: Optional[Order] = None
+
+    @property
+    def card_payment_method_specific_input(self) -> Optional[CompletePaymentCardPaymentMethodSpecificInput]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.complete_payment_card_payment_method_specific_input.CompletePaymentCardPaymentMethodSpecificInput`
+        """
+        return self.__card_payment_method_specific_input
+
+    @card_payment_method_specific_input.setter
+    def card_payment_method_specific_input(self, value: Optional[CompletePaymentCardPaymentMethodSpecificInput]) -> None:
+        self.__card_payment_method_specific_input = value
+
+    @property
+    def order(self) -> Optional[Order]:
+        """
+        | The order object contains order-related data; Please note that this object is required to submit the amount.
+
+        Type: :class:`onlinepayments.sdk.domain.order.Order`
+        """
+        return self.__order
+
+    @order.setter
+    def order(self, value: Optional[Order]) -> None:
+        self.__order = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CompletePaymentRequest, self).to_dictionary()
+        if self.card_payment_method_specific_input is not None:
+            dictionary['cardPaymentMethodSpecificInput'] = self.card_payment_method_specific_input.to_dictionary()
+        if self.order is not None:
+            dictionary['order'] = self.order.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CompletePaymentRequest':
+        super(CompletePaymentRequest, self).from_dictionary(dictionary)
+        if 'cardPaymentMethodSpecificInput' in dictionary:
+            if not isinstance(dictionary['cardPaymentMethodSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardPaymentMethodSpecificInput']))
+            value = CompletePaymentCardPaymentMethodSpecificInput()
+            self.card_payment_method_specific_input = value.from_dictionary(dictionary['cardPaymentMethodSpecificInput'])
+        if 'order' in dictionary:
+            if not isinstance(dictionary['order'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['order']))
+            value = Order()
+            self.order = value.from_dictionary(dictionary['order'])
+        return self

onlinepayments/sdk/domain/complete_payment_response.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .merchant_action import MerchantAction
+from .payment_creation_output import PaymentCreationOutput
+from .payment_response import PaymentResponse
+
+
+class CompletePaymentResponse(DataObject):
+
+    __creation_output: Optional[PaymentCreationOutput] = None
+    __merchant_action: Optional[MerchantAction] = None
+    __payment: Optional[PaymentResponse] = None
+
+    @property
+    def creation_output(self) -> Optional[PaymentCreationOutput]:
+        """
+        | This object contains the details of the created payment.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_creation_output.PaymentCreationOutput`
+        """
+        return self.__creation_output
+
+    @creation_output.setter
+    def creation_output(self, value: Optional[PaymentCreationOutput]) -> None:
+        self.__creation_output = value
+
+    @property
+    def merchant_action(self) -> Optional[MerchantAction]:
+        """
+        | This object contains the action, including the needed data, that you should perform next. This could involve showing instructions, displaying the transaction results, or redirecting to a third party to complete the payment.
+
+        Type: :class:`onlinepayments.sdk.domain.merchant_action.MerchantAction`
+        """
+        return self.__merchant_action
+
+    @merchant_action.setter
+    def merchant_action(self, value: Optional[MerchantAction]) -> None:
+        self.__merchant_action = value
+
+    @property
+    def payment(self) -> Optional[PaymentResponse]:
+        """
+        | This object holds the properties related to the payment.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_response.PaymentResponse`
+        """
+        return self.__payment
+
+    @payment.setter
+    def payment(self, value: Optional[PaymentResponse]) -> None:
+        self.__payment = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CompletePaymentResponse, self).to_dictionary()
+        if self.creation_output is not None:
+            dictionary['creationOutput'] = self.creation_output.to_dictionary()
+        if self.merchant_action is not None:
+            dictionary['merchantAction'] = self.merchant_action.to_dictionary()
+        if self.payment is not None:
+            dictionary['payment'] = self.payment.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CompletePaymentResponse':
+        super(CompletePaymentResponse, self).from_dictionary(dictionary)
+        if 'creationOutput' in dictionary:
+            if not isinstance(dictionary['creationOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['creationOutput']))
+            value = PaymentCreationOutput()
+            self.creation_output = value.from_dictionary(dictionary['creationOutput'])
+        if 'merchantAction' in dictionary:
+            if not isinstance(dictionary['merchantAction'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['merchantAction']))
+            value = MerchantAction()
+            self.merchant_action = value.from_dictionary(dictionary['merchantAction'])
+        if 'payment' in dictionary:
+            if not isinstance(dictionary['payment'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payment']))
+            value = PaymentResponse()
+            self.payment = value.from_dictionary(dictionary['payment'])
+        return self

onlinepayments/sdk/domain/contact_details.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ContactDetails(DataObject):
+
+    __email_address: Optional[str] = None
+    __fax_number: Optional[str] = None
+    __mobile_phone_number: Optional[str] = None
+    __phone_number: Optional[str] = None
+    __work_phone_number: Optional[str] = None
+
+    @property
+    def email_address(self) -> Optional[str]:
+        """
+        | Email address of the customer
+
+        Type: str
+        """
+        return self.__email_address
+
+    @email_address.setter
+    def email_address(self, value: Optional[str]) -> None:
+        self.__email_address = value
+
+    @property
+    def fax_number(self) -> Optional[str]:
+        """
+        | International version of the fax number of the customer including the leading + (i.e. +16127779311)
+
+        Type: str
+        """
+        return self.__fax_number
+
+    @fax_number.setter
+    def fax_number(self, value: Optional[str]) -> None:
+        self.__fax_number = value
+
+    @property
+    def mobile_phone_number(self) -> Optional[str]:
+        """
+        | International version of the mobile phone number of the customer including the leading + (i.e. +16127779311)
+
+        Type: str
+        """
+        return self.__mobile_phone_number
+
+    @mobile_phone_number.setter
+    def mobile_phone_number(self, value: Optional[str]) -> None:
+        self.__mobile_phone_number = value
+
+    @property
+    def phone_number(self) -> Optional[str]:
+        """
+        | International version of the phone number of the customer including the leading + (i.e. +16127779311)
+
+        Type: str
+        """
+        return self.__phone_number
+
+    @phone_number.setter
+    def phone_number(self, value: Optional[str]) -> None:
+        self.__phone_number = value
+
+    @property
+    def work_phone_number(self) -> Optional[str]:
+        """
+        | International version of the work phone number of the customer including the leading + (i.e. +31235671500)
+
+        Type: str
+        """
+        return self.__work_phone_number
+
+    @work_phone_number.setter
+    def work_phone_number(self, value: Optional[str]) -> None:
+        self.__work_phone_number = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ContactDetails, self).to_dictionary()
+        if self.email_address is not None:
+            dictionary['emailAddress'] = self.email_address
+        if self.fax_number is not None:
+            dictionary['faxNumber'] = self.fax_number
+        if self.mobile_phone_number is not None:
+            dictionary['mobilePhoneNumber'] = self.mobile_phone_number
+        if self.phone_number is not None:
+            dictionary['phoneNumber'] = self.phone_number
+        if self.work_phone_number is not None:
+            dictionary['workPhoneNumber'] = self.work_phone_number
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ContactDetails':
+        super(ContactDetails, self).from_dictionary(dictionary)
+        if 'emailAddress' in dictionary:
+            self.email_address = dictionary['emailAddress']
+        if 'faxNumber' in dictionary:
+            self.fax_number = dictionary['faxNumber']
+        if 'mobilePhoneNumber' in dictionary:
+            self.mobile_phone_number = dictionary['mobilePhoneNumber']
+        if 'phoneNumber' in dictionary:
+            self.phone_number = dictionary['phoneNumber']
+        if 'workPhoneNumber' in dictionary:
+            self.work_phone_number = dictionary['workPhoneNumber']
+        return self

onlinepayments/sdk/domain/create_certificate_response.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class CreateCertificateResponse(DataObject):
+
+    __certificate_id: Optional[str] = None
+    __signed_certificate: Optional[str] = None
+
+    @property
+    def certificate_id(self) -> Optional[str]:
+        """
+        | A unique identifier for the certificate generated on the GoPay platform, facilitating effective tracking and management of detokenization actions.
+
+        Type: str
+        """
+        return self.__certificate_id
+
+    @certificate_id.setter
+    def certificate_id(self, value: Optional[str]) -> None:
+        self.__certificate_id = value
+
+    @property
+    def signed_certificate(self) -> Optional[str]:
+        """
+        | The signed certificate in base64 encoded string format, used for secure communication and authentication in API transactions.
+
+        Type: str
+        """
+        return self.__signed_certificate
+
+    @signed_certificate.setter
+    def signed_certificate(self, value: Optional[str]) -> None:
+        self.__signed_certificate = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CreateCertificateResponse, self).to_dictionary()
+        if self.certificate_id is not None:
+            dictionary['certificateId'] = self.certificate_id
+        if self.signed_certificate is not None:
+            dictionary['signedCertificate'] = self.signed_certificate
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CreateCertificateResponse':
+        super(CreateCertificateResponse, self).from_dictionary(dictionary)
+        if 'certificateId' in dictionary:
+            self.certificate_id = dictionary['certificateId']
+        if 'signedCertificate' in dictionary:
+            self.signed_certificate = dictionary['signedCertificate']
+        return self