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

onlinepayments/sdk/domain/payment_response.py

@@ -0,0 +1,143 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .hosted_checkout_specific_output import HostedCheckoutSpecificOutput
+from .payment_output import PaymentOutput
+from .payment_status_output import PaymentStatusOutput
+from .session_details import SessionDetails
+
+
+class PaymentResponse(DataObject):
+
+    __hosted_checkout_specific_output: Optional[HostedCheckoutSpecificOutput] = None
+    __id: Optional[str] = None
+    __payment_output: Optional[PaymentOutput] = None
+    __session_details: Optional[SessionDetails] = None
+    __status: Optional[str] = None
+    __status_output: Optional[PaymentStatusOutput] = None
+
+    @property
+    def hosted_checkout_specific_output(self) -> Optional[HostedCheckoutSpecificOutput]:
+        """
+        | Hosted Checkout specific information. Populated if the payment was created on the platform through a Hosted Checkout.
+
+        Type: :class:`onlinepayments.sdk.domain.hosted_checkout_specific_output.HostedCheckoutSpecificOutput`
+        """
+        return self.__hosted_checkout_specific_output
+
+    @hosted_checkout_specific_output.setter
+    def hosted_checkout_specific_output(self, value: Optional[HostedCheckoutSpecificOutput]) -> None:
+        self.__hosted_checkout_specific_output = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | This is our unique payment transaction identifier.
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def payment_output(self) -> Optional[PaymentOutput]:
+        """
+        | Object containing payment details
+
+        Type: :class:`onlinepayments.sdk.domain.payment_output.PaymentOutput`
+        """
+        return self.__payment_output
+
+    @payment_output.setter
+    def payment_output(self, value: Optional[PaymentOutput]) -> None:
+        self.__payment_output = value
+
+    @property
+    def session_details(self) -> Optional[SessionDetails]:
+        """
+        | Session context information. This denotes the origin of the payment session, where the session originated from and that session's unique identifier
+
+        Type: :class:`onlinepayments.sdk.domain.session_details.SessionDetails`
+        """
+        return self.__session_details
+
+    @session_details.setter
+    def session_details(self, value: Optional[SessionDetails]) -> None:
+        self.__session_details = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | Current high-level status of the payment in a human-readable form.
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    @property
+    def status_output(self) -> Optional[PaymentStatusOutput]:
+        """
+        | This object has the numeric representation of the current payment status, the timestamp of the last status change, and the performable action on the current payment resource. In case of failed payments and negative scenarios, detailed error information is listed.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_status_output.PaymentStatusOutput`
+        """
+        return self.__status_output
+
+    @status_output.setter
+    def status_output(self, value: Optional[PaymentStatusOutput]) -> None:
+        self.__status_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentResponse, self).to_dictionary()
+        if self.hosted_checkout_specific_output is not None:
+            dictionary['hostedCheckoutSpecificOutput'] = self.hosted_checkout_specific_output.to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.payment_output is not None:
+            dictionary['paymentOutput'] = self.payment_output.to_dictionary()
+        if self.session_details is not None:
+            dictionary['sessionDetails'] = self.session_details.to_dictionary()
+        if self.status is not None:
+            dictionary['status'] = self.status
+        if self.status_output is not None:
+            dictionary['statusOutput'] = self.status_output.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentResponse':
+        super(PaymentResponse, self).from_dictionary(dictionary)
+        if 'hostedCheckoutSpecificOutput' in dictionary:
+            if not isinstance(dictionary['hostedCheckoutSpecificOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['hostedCheckoutSpecificOutput']))
+            value = HostedCheckoutSpecificOutput()
+            self.hosted_checkout_specific_output = value.from_dictionary(dictionary['hostedCheckoutSpecificOutput'])
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'paymentOutput' in dictionary:
+            if not isinstance(dictionary['paymentOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentOutput']))
+            value = PaymentOutput()
+            self.payment_output = value.from_dictionary(dictionary['paymentOutput'])
+        if 'sessionDetails' in dictionary:
+            if not isinstance(dictionary['sessionDetails'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sessionDetails']))
+            value = SessionDetails()
+            self.session_details = value.from_dictionary(dictionary['sessionDetails'])
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        if 'statusOutput' in dictionary:
+            if not isinstance(dictionary['statusOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['statusOutput']))
+            value = PaymentStatusOutput()
+            self.status_output = value.from_dictionary(dictionary['statusOutput'])
+        return self

onlinepayments/sdk/domain/payment_status_output.py

@@ -0,0 +1,152 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .api_error import APIError
+from .data_object import DataObject
+
+
+class PaymentStatusOutput(DataObject):
+
+    __errors: Optional[List[APIError]] = None
+    __is_authorized: Optional[bool] = None
+    __is_cancellable: Optional[bool] = None
+    __is_refundable: 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_authorized(self) -> Optional[bool]:
+        """
+        | Indicates if the transaction has been authorized
+
+        Type: bool
+        """
+        return self.__is_authorized
+
+    @is_authorized.setter
+    def is_authorized(self, value: Optional[bool]) -> None:
+        self.__is_authorized = value
+
+    @property
+    def is_cancellable(self) -> Optional[bool]:
+        """
+        | Flag indicating if the payment can be cancelled
+
+        Type: bool
+        """
+        return self.__is_cancellable
+
+    @is_cancellable.setter
+    def is_cancellable(self, value: Optional[bool]) -> None:
+        self.__is_cancellable = value
+
+    @property
+    def is_refundable(self) -> Optional[bool]:
+        """
+        | This is a flag indicating whether the payment can be refunded.
+
+        Type: bool
+        """
+        return self.__is_refundable
+
+    @is_refundable.setter
+    def is_refundable(self, value: Optional[bool]) -> None:
+        self.__is_refundable = 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(PaymentStatusOutput, 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_authorized is not None:
+            dictionary['isAuthorized'] = self.is_authorized
+        if self.is_cancellable is not None:
+            dictionary['isCancellable'] = self.is_cancellable
+        if self.is_refundable is not None:
+            dictionary['isRefundable'] = self.is_refundable
+        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) -> 'PaymentStatusOutput':
+        super(PaymentStatusOutput, 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 'isAuthorized' in dictionary:
+            self.is_authorized = dictionary['isAuthorized']
+        if 'isCancellable' in dictionary:
+            self.is_cancellable = dictionary['isCancellable']
+        if 'isRefundable' in dictionary:
+            self.is_refundable = dictionary['isRefundable']
+        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/payout_error_response.py

@@ -0,0 +1,80 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .api_error import APIError
+from .data_object import DataObject
+from .payout_result import PayoutResult
+
+
+class PayoutErrorResponse(DataObject):
+
+    __error_id: Optional[str] = None
+    __errors: Optional[List[APIError]] = None
+    __payout_result: Optional[PayoutResult] = None
+
+    @property
+    def error_id(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__error_id
+
+    @error_id.setter
+    def error_id(self, value: Optional[str]) -> None:
+        self.__error_id = value
+
+    @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 payout_result(self) -> Optional[PayoutResult]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.payout_result.PayoutResult`
+        """
+        return self.__payout_result
+
+    @payout_result.setter
+    def payout_result(self, value: Optional[PayoutResult]) -> None:
+        self.__payout_result = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PayoutErrorResponse, self).to_dictionary()
+        if self.error_id is not None:
+            dictionary['errorId'] = self.error_id
+        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.payout_result is not None:
+            dictionary['payoutResult'] = self.payout_result.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PayoutErrorResponse':
+        super(PayoutErrorResponse, self).from_dictionary(dictionary)
+        if 'errorId' in dictionary:
+            self.error_id = dictionary['errorId']
+        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 'payoutResult' in dictionary:
+            if not isinstance(dictionary['payoutResult'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payoutResult']))
+            value = PayoutResult()
+            self.payout_result = value.from_dictionary(dictionary['payoutResult'])
+        return self

onlinepayments/sdk/domain/payout_output.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+
+
+class PayoutOutput(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __payout_reason: Optional[str] = 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 payout_reason(self) -> Optional[str]:
+        """
+        | Allows you to additionally specify the reason for initiating the payout for authorization purposes. If this field is not specified, authorization of the payment will be made according to your merchant profile. Possible values are:
+        
+        * Gambling
+        * Refund
+        * Loyalty
+
+        Type: str
+        """
+        return self.__payout_reason
+
+    @payout_reason.setter
+    def payout_reason(self, value: Optional[str]) -> None:
+        self.__payout_reason = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PayoutOutput, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.payout_reason is not None:
+            dictionary['payoutReason'] = self.payout_reason
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PayoutOutput':
+        super(PayoutOutput, 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 'payoutReason' in dictionary:
+            self.payout_reason = dictionary['payoutReason']
+        return self

onlinepayments/sdk/domain/payout_response.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payout_output import PayoutOutput
+from .payout_status_output import PayoutStatusOutput
+
+
+class PayoutResponse(DataObject):
+
+    __id: Optional[str] = None
+    __payout_output: Optional[PayoutOutput] = None
+    __status: Optional[str] = None
+    __status_output: Optional[PayoutStatusOutput] = None
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def payout_output(self) -> Optional[PayoutOutput]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.payout_output.PayoutOutput`
+        """
+        return self.__payout_output
+
+    @payout_output.setter
+    def payout_output(self, value: Optional[PayoutOutput]) -> None:
+        self.__payout_output = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | Current high-level status of the payout in a human-readable form.
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    @property
+    def status_output(self) -> Optional[PayoutStatusOutput]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.payout_status_output.PayoutStatusOutput`
+        """
+        return self.__status_output
+
+    @status_output.setter
+    def status_output(self, value: Optional[PayoutStatusOutput]) -> None:
+        self.__status_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PayoutResponse, self).to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.payout_output is not None:
+            dictionary['payoutOutput'] = self.payout_output.to_dictionary()
+        if self.status is not None:
+            dictionary['status'] = self.status
+        if self.status_output is not None:
+            dictionary['statusOutput'] = self.status_output.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PayoutResponse':
+        super(PayoutResponse, self).from_dictionary(dictionary)
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'payoutOutput' in dictionary:
+            if not isinstance(dictionary['payoutOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payoutOutput']))
+            value = PayoutOutput()
+            self.payout_output = value.from_dictionary(dictionary['payoutOutput'])
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        if 'statusOutput' in dictionary:
+            if not isinstance(dictionary['statusOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['statusOutput']))
+            value = PayoutStatusOutput()
+            self.status_output = value.from_dictionary(dictionary['statusOutput'])
+        return self

onlinepayments/sdk/domain/payout_result.py

@@ -0,0 +1,93 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payout_output import PayoutOutput
+from .payout_status_output import PayoutStatusOutput
+
+
+class PayoutResult(DataObject):
+
+    __id: Optional[str] = None
+    __payout_output: Optional[PayoutOutput] = None
+    __status: Optional[str] = None
+    __status_output: Optional[PayoutStatusOutput] = None
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def payout_output(self) -> Optional[PayoutOutput]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.payout_output.PayoutOutput`
+        """
+        return self.__payout_output
+
+    @payout_output.setter
+    def payout_output(self, value: Optional[PayoutOutput]) -> None:
+        self.__payout_output = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | Current high-level status of the payout in a human-readable form.
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    @property
+    def status_output(self) -> Optional[PayoutStatusOutput]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.payout_status_output.PayoutStatusOutput`
+        """
+        return self.__status_output
+
+    @status_output.setter
+    def status_output(self, value: Optional[PayoutStatusOutput]) -> None:
+        self.__status_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PayoutResult, self).to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.payout_output is not None:
+            dictionary['payoutOutput'] = self.payout_output.to_dictionary()
+        if self.status is not None:
+            dictionary['status'] = self.status
+        if self.status_output is not None:
+            dictionary['statusOutput'] = self.status_output.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PayoutResult':
+        super(PayoutResult, self).from_dictionary(dictionary)
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'payoutOutput' in dictionary:
+            if not isinstance(dictionary['payoutOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['payoutOutput']))
+            value = PayoutOutput()
+            self.payout_output = value.from_dictionary(dictionary['payoutOutput'])
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        if 'statusOutput' in dictionary:
+            if not isinstance(dictionary['statusOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['statusOutput']))
+            value = PayoutStatusOutput()
+            self.status_output = value.from_dictionary(dictionary['statusOutput'])
+        return self