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

onlinepayments/sdk/domain/calculate_surcharge_request.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .card_source import CardSource
+from .data_object import DataObject
+
+
+class CalculateSurchargeRequest(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __card_source: Optional[CardSource] = 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 card_source(self) -> Optional[CardSource]:
+        """
+        | Contains elements from which card number can be obtained.
+
+        Type: :class:`onlinepayments.sdk.domain.card_source.CardSource`
+        """
+        return self.__card_source
+
+    @card_source.setter
+    def card_source(self, value: Optional[CardSource]) -> None:
+        self.__card_source = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CalculateSurchargeRequest, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.card_source is not None:
+            dictionary['cardSource'] = self.card_source.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CalculateSurchargeRequest':
+        super(CalculateSurchargeRequest, 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 'cardSource' in dictionary:
+            if not isinstance(dictionary['cardSource'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cardSource']))
+            value = CardSource()
+            self.card_source = value.from_dictionary(dictionary['cardSource'])
+        return self

onlinepayments/sdk/domain/calculate_surcharge_response.py

@@ -0,0 +1,44 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+from .surcharge import Surcharge
+
+
+class CalculateSurchargeResponse(DataObject):
+
+    __surcharges: Optional[List[Surcharge]] = None
+
+    @property
+    def surcharges(self) -> Optional[List[Surcharge]]:
+        """
+        Type: list[:class:`onlinepayments.sdk.domain.surcharge.Surcharge`]
+        """
+        return self.__surcharges
+
+    @surcharges.setter
+    def surcharges(self, value: Optional[List[Surcharge]]) -> None:
+        self.__surcharges = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CalculateSurchargeResponse, self).to_dictionary()
+        if self.surcharges is not None:
+            dictionary['surcharges'] = []
+            for element in self.surcharges:
+                if element is not None:
+                    dictionary['surcharges'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CalculateSurchargeResponse':
+        super(CalculateSurchargeResponse, self).from_dictionary(dictionary)
+        if 'surcharges' in dictionary:
+            if not isinstance(dictionary['surcharges'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['surcharges']))
+            self.surcharges = []
+            for element in dictionary['surcharges']:
+                value = Surcharge()
+                self.surcharges.append(value.from_dictionary(element))
+        return self

onlinepayments/sdk/domain/cancel_payment_batch_request.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .cancel_payment_request import CancelPaymentRequest
+from .data_object import DataObject
+
+
+class CancelPaymentBatchRequest(DataObject):
+
+    __cancel: Optional[CancelPaymentRequest] = None
+    __payment_id: Optional[str] = None
+
+    @property
+    def cancel(self) -> Optional[CancelPaymentRequest]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.cancel_payment_request.CancelPaymentRequest`
+        """
+        return self.__cancel
+
+    @cancel.setter
+    def cancel(self, value: Optional[CancelPaymentRequest]) -> None:
+        self.__cancel = value
+
+    @property
+    def payment_id(self) -> Optional[str]:
+        """
+        | This is our unique payment transaction identifier.
+
+        Type: str
+        """
+        return self.__payment_id
+
+    @payment_id.setter
+    def payment_id(self, value: Optional[str]) -> None:
+        self.__payment_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CancelPaymentBatchRequest, self).to_dictionary()
+        if self.cancel is not None:
+            dictionary['cancel'] = self.cancel.to_dictionary()
+        if self.payment_id is not None:
+            dictionary['paymentId'] = self.payment_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CancelPaymentBatchRequest':
+        super(CancelPaymentBatchRequest, self).from_dictionary(dictionary)
+        if 'cancel' in dictionary:
+            if not isinstance(dictionary['cancel'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['cancel']))
+            value = CancelPaymentRequest()
+            self.cancel = value.from_dictionary(dictionary['cancel'])
+        if 'paymentId' in dictionary:
+            self.payment_id = dictionary['paymentId']
+        return self

onlinepayments/sdk/domain/cancel_payment_request.py

@@ -0,0 +1,130 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+from .line_item_detail import LineItemDetail
+from .operation_payment_references import OperationPaymentReferences
+from .shipping_detail import ShippingDetail
+
+
+class CancelPaymentRequest(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __is_final: Optional[bool] = None
+    __line_item_details: Optional[List[LineItemDetail]] = None
+    __operation_references: Optional[OperationPaymentReferences] = None
+    __shipping: Optional[ShippingDetail] = 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 is_final(self) -> Optional[bool]:
+        """
+        | This property indicates whether this will be the final operation. The default value for this property is false.
+
+        Type: bool
+        """
+        return self.__is_final
+
+    @is_final.setter
+    def is_final(self, value: Optional[bool]) -> None:
+        self.__is_final = value
+
+    @property
+    def line_item_details(self) -> Optional[List[LineItemDetail]]:
+        """
+        | List of lineItemIds and quantities for capture/refund/cancellation.
+
+        Type: list[:class:`onlinepayments.sdk.domain.line_item_detail.LineItemDetail`]
+        """
+        return self.__line_item_details
+
+    @line_item_details.setter
+    def line_item_details(self, value: Optional[List[LineItemDetail]]) -> None:
+        self.__line_item_details = value
+
+    @property
+    def operation_references(self) -> Optional[OperationPaymentReferences]:
+        """
+        | Object that holds all reference properties that are linked to this transaction
+
+        Type: :class:`onlinepayments.sdk.domain.operation_payment_references.OperationPaymentReferences`
+        """
+        return self.__operation_references
+
+    @operation_references.setter
+    def operation_references(self, value: Optional[OperationPaymentReferences]) -> None:
+        self.__operation_references = value
+
+    @property
+    def shipping(self) -> Optional[ShippingDetail]:
+        """
+        | Object containing the details of the shipping of the order
+
+        Type: :class:`onlinepayments.sdk.domain.shipping_detail.ShippingDetail`
+        """
+        return self.__shipping
+
+    @shipping.setter
+    def shipping(self, value: Optional[ShippingDetail]) -> None:
+        self.__shipping = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(CancelPaymentRequest, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.is_final is not None:
+            dictionary['isFinal'] = self.is_final
+        if self.line_item_details is not None:
+            dictionary['lineItemDetails'] = []
+            for element in self.line_item_details:
+                if element is not None:
+                    dictionary['lineItemDetails'].append(element.to_dictionary())
+        if self.operation_references is not None:
+            dictionary['operationReferences'] = self.operation_references.to_dictionary()
+        if self.shipping is not None:
+            dictionary['shipping'] = self.shipping.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CancelPaymentRequest':
+        super(CancelPaymentRequest, 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 'isFinal' in dictionary:
+            self.is_final = dictionary['isFinal']
+        if 'lineItemDetails' in dictionary:
+            if not isinstance(dictionary['lineItemDetails'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['lineItemDetails']))
+            self.line_item_details = []
+            for element in dictionary['lineItemDetails']:
+                value = LineItemDetail()
+                self.line_item_details.append(value.from_dictionary(element))
+        if 'operationReferences' in dictionary:
+            if not isinstance(dictionary['operationReferences'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['operationReferences']))
+            value = OperationPaymentReferences()
+            self.operation_references = value.from_dictionary(dictionary['operationReferences'])
+        if 'shipping' in dictionary:
+            if not isinstance(dictionary['shipping'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shipping']))
+            value = ShippingDetail()
+            self.shipping = value.from_dictionary(dictionary['shipping'])
+        return self

onlinepayments/sdk/domain/cancel_payment_response.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_response import PaymentResponse
+
+
+class CancelPaymentResponse(DataObject):
+
+    __payment: Optional[PaymentResponse] = None
+
+    @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(CancelPaymentResponse, self).to_dictionary()
+        if self.payment is not None:
+            dictionary['payment'] = self.payment.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'CancelPaymentResponse':
+        super(CancelPaymentResponse, self).from_dictionary(dictionary)
+        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/capture.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .capture_output import CaptureOutput
+from .capture_status_output import CaptureStatusOutput
+from .data_object import DataObject
+
+
+class Capture(DataObject):
+
+    __capture_output: Optional[CaptureOutput] = None
+    __id: Optional[str] = None
+    __status: Optional[str] = None
+    __status_output: Optional[CaptureStatusOutput] = None
+
+    @property
+    def capture_output(self) -> Optional[CaptureOutput]:
+        """
+        | Object containing capture details
+
+        Type: :class:`onlinepayments.sdk.domain.capture_output.CaptureOutput`
+        """
+        return self.__capture_output
+
+    @capture_output.setter
+    def capture_output(self, value: Optional[CaptureOutput]) -> None:
+        self.__capture_output = value
+
+    @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 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[CaptureStatusOutput]:
+        """
+        | This object has the numeric representation of the current capture status, timestamp of last status change and 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.capture_status_output.CaptureStatusOutput`
+        """
+        return self.__status_output
+
+    @status_output.setter
+    def status_output(self, value: Optional[CaptureStatusOutput]) -> None:
+        self.__status_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Capture, self).to_dictionary()
+        if self.capture_output is not None:
+            dictionary['captureOutput'] = self.capture_output.to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        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) -> 'Capture':
+        super(Capture, self).from_dictionary(dictionary)
+        if 'captureOutput' in dictionary:
+            if not isinstance(dictionary['captureOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['captureOutput']))
+            value = CaptureOutput()
+            self.capture_output = value.from_dictionary(dictionary['captureOutput'])
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        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 = CaptureStatusOutput()
+            self.status_output = value.from_dictionary(dictionary['statusOutput'])
+        return self