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

onlinepayments/sdk/domain/operation_output.py

@@ -0,0 +1,161 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+from .operation_payment_references import OperationPaymentReferences
+from .payment_references import PaymentReferences
+from .payment_status_output import PaymentStatusOutput
+
+
+class OperationOutput(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __id: Optional[str] = None
+    __operation_references: Optional[OperationPaymentReferences] = None
+    __payment_method: Optional[str] = None
+    __references: Optional[PaymentReferences] = None
+    __status: Optional[str] = None
+    __status_output: Optional[PaymentStatusOutput] = 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 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 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 payment_method(self) -> Optional[str]:
+        """
+        | Payment method identifier used by the our payment engine.
+
+        Type: str
+        """
+        return self.__payment_method
+
+    @payment_method.setter
+    def payment_method(self, value: Optional[str]) -> None:
+        self.__payment_method = value
+
+    @property
+    def references(self) -> Optional[PaymentReferences]:
+        """
+        | Object that holds all reference properties that are linked to this transaction. **Deprecated for capture/refund**: Use operationReferences instead.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_references.PaymentReferences`
+        """
+        return self.__references
+
+    @references.setter
+    def references(self, value: Optional[PaymentReferences]) -> None:
+        self.__references = 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(OperationOutput, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.operation_references is not None:
+            dictionary['operationReferences'] = self.operation_references.to_dictionary()
+        if self.payment_method is not None:
+            dictionary['paymentMethod'] = self.payment_method
+        if self.references is not None:
+            dictionary['references'] = self.references.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) -> 'OperationOutput':
+        super(OperationOutput, 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 'id' in dictionary:
+            self.id = dictionary['id']
+        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 'paymentMethod' in dictionary:
+            self.payment_method = dictionary['paymentMethod']
+        if 'references' in dictionary:
+            if not isinstance(dictionary['references'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['references']))
+            value = PaymentReferences()
+            self.references = value.from_dictionary(dictionary['references'])
+        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/operation_payment_references.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class OperationPaymentReferences(DataObject):
+
+    __merchant_reference: Optional[str] = None
+    __operation_group_reference: Optional[str] = None
+
+    @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(OperationPaymentReferences, self).to_dictionary()
+        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) -> 'OperationPaymentReferences':
+        super(OperationPaymentReferences, self).from_dictionary(dictionary)
+        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.py

@@ -0,0 +1,213 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .additional_order_input import AdditionalOrderInput
+from .amount_of_money import AmountOfMoney
+from .customer import Customer
+from .data_object import DataObject
+from .discount import Discount
+from .order_references import OrderReferences
+from .shipping import Shipping
+from .shopping_cart import ShoppingCart
+from .surcharge_specific_input import SurchargeSpecificInput
+
+
+class Order(DataObject):
+
+    __additional_input: Optional[AdditionalOrderInput] = None
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __customer: Optional[Customer] = None
+    __discount: Optional[Discount] = None
+    __references: Optional[OrderReferences] = None
+    __shipping: Optional[Shipping] = None
+    __shopping_cart: Optional[ShoppingCart] = None
+    __surcharge_specific_input: Optional[SurchargeSpecificInput] = None
+    __total_tax_amount: Optional[int] = None
+
+    @property
+    def additional_input(self) -> Optional[AdditionalOrderInput]:
+        """
+        | This object contains additional input on the order.
+
+        Type: :class:`onlinepayments.sdk.domain.additional_order_input.AdditionalOrderInput`
+        """
+        return self.__additional_input
+
+    @additional_input.setter
+    def additional_input(self, value: Optional[AdditionalOrderInput]) -> None:
+        self.__additional_input = value
+
+    @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 customer(self) -> Optional[Customer]:
+        """
+        | Object containing the details of the customer
+
+        Type: :class:`onlinepayments.sdk.domain.customer.Customer`
+        """
+        return self.__customer
+
+    @customer.setter
+    def customer(self, value: Optional[Customer]) -> None:
+        self.__customer = value
+
+    @property
+    def discount(self) -> Optional[Discount]:
+        """
+        | Object to apply a discount to the total basket by adding a discount line.
+
+        Type: :class:`onlinepayments.sdk.domain.discount.Discount`
+        """
+        return self.__discount
+
+    @discount.setter
+    def discount(self, value: Optional[Discount]) -> None:
+        self.__discount = value
+
+    @property
+    def references(self) -> Optional[OrderReferences]:
+        """
+        | Object that holds all reference properties that are linked to this transaction
+
+        Type: :class:`onlinepayments.sdk.domain.order_references.OrderReferences`
+        """
+        return self.__references
+
+    @references.setter
+    def references(self, value: Optional[OrderReferences]) -> None:
+        self.__references = value
+
+    @property
+    def shipping(self) -> Optional[Shipping]:
+        """
+        | Object containing information regarding shipping / delivery
+
+        Type: :class:`onlinepayments.sdk.domain.shipping.Shipping`
+        """
+        return self.__shipping
+
+    @shipping.setter
+    def shipping(self, value: Optional[Shipping]) -> None:
+        self.__shipping = value
+
+    @property
+    def shopping_cart(self) -> Optional[ShoppingCart]:
+        """
+        | Shopping cart data, including items and specific amounts.
+
+        Type: :class:`onlinepayments.sdk.domain.shopping_cart.ShoppingCart`
+        """
+        return self.__shopping_cart
+
+    @shopping_cart.setter
+    def shopping_cart(self, value: Optional[ShoppingCart]) -> None:
+        self.__shopping_cart = value
+
+    @property
+    def surcharge_specific_input(self) -> Optional[SurchargeSpecificInput]:
+        """
+        | Object containing specific input required to apply surcharging to an order.
+
+        Type: :class:`onlinepayments.sdk.domain.surcharge_specific_input.SurchargeSpecificInput`
+        """
+        return self.__surcharge_specific_input
+
+    @surcharge_specific_input.setter
+    def surcharge_specific_input(self, value: Optional[SurchargeSpecificInput]) -> None:
+        self.__surcharge_specific_input = value
+
+    @property
+    def total_tax_amount(self) -> Optional[int]:
+        """
+        | tax amount, in minor currency units of the order. Omit if not applicable or not known. This amount is assumed to be included in the order.AmountOfMoney for the payment. There is no validation on this field, outside the fact the amount should be lower than the total payment amount.
+
+        Type: int
+        """
+        return self.__total_tax_amount
+
+    @total_tax_amount.setter
+    def total_tax_amount(self, value: Optional[int]) -> None:
+        self.__total_tax_amount = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Order, self).to_dictionary()
+        if self.additional_input is not None:
+            dictionary['additionalInput'] = self.additional_input.to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.customer is not None:
+            dictionary['customer'] = self.customer.to_dictionary()
+        if self.discount is not None:
+            dictionary['discount'] = self.discount.to_dictionary()
+        if self.references is not None:
+            dictionary['references'] = self.references.to_dictionary()
+        if self.shipping is not None:
+            dictionary['shipping'] = self.shipping.to_dictionary()
+        if self.shopping_cart is not None:
+            dictionary['shoppingCart'] = self.shopping_cart.to_dictionary()
+        if self.surcharge_specific_input is not None:
+            dictionary['surchargeSpecificInput'] = self.surcharge_specific_input.to_dictionary()
+        if self.total_tax_amount is not None:
+            dictionary['totalTaxAmount'] = self.total_tax_amount
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Order':
+        super(Order, self).from_dictionary(dictionary)
+        if 'additionalInput' in dictionary:
+            if not isinstance(dictionary['additionalInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['additionalInput']))
+            value = AdditionalOrderInput()
+            self.additional_input = value.from_dictionary(dictionary['additionalInput'])
+        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 'customer' in dictionary:
+            if not isinstance(dictionary['customer'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customer']))
+            value = Customer()
+            self.customer = value.from_dictionary(dictionary['customer'])
+        if 'discount' in dictionary:
+            if not isinstance(dictionary['discount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['discount']))
+            value = Discount()
+            self.discount = value.from_dictionary(dictionary['discount'])
+        if 'references' in dictionary:
+            if not isinstance(dictionary['references'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['references']))
+            value = OrderReferences()
+            self.references = value.from_dictionary(dictionary['references'])
+        if 'shipping' in dictionary:
+            if not isinstance(dictionary['shipping'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shipping']))
+            value = Shipping()
+            self.shipping = value.from_dictionary(dictionary['shipping'])
+        if 'shoppingCart' in dictionary:
+            if not isinstance(dictionary['shoppingCart'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shoppingCart']))
+            value = ShoppingCart()
+            self.shopping_cart = value.from_dictionary(dictionary['shoppingCart'])
+        if 'surchargeSpecificInput' in dictionary:
+            if not isinstance(dictionary['surchargeSpecificInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['surchargeSpecificInput']))
+            value = SurchargeSpecificInput()
+            self.surcharge_specific_input = value.from_dictionary(dictionary['surchargeSpecificInput'])
+        if 'totalTaxAmount' in dictionary:
+            self.total_tax_amount = dictionary['totalTaxAmount']
+        return self

onlinepayments/sdk/domain/order_line_details.py

@@ -0,0 +1,189 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class OrderLineDetails(DataObject):
+
+    __discount_amount: Optional[int] = None
+    __product_brand: Optional[str] = None
+    __product_code: Optional[str] = None
+    __product_name: Optional[str] = None
+    __product_price: Optional[int] = None
+    __product_type: Optional[str] = None
+    __quantity: Optional[int] = None
+    __tax_amount: Optional[int] = None
+    __unit: Optional[str] = None
+
+    @property
+    def discount_amount(self) -> Optional[int]:
+        """
+        | Amount in the smallest currency unit, i.e.:
+        
+        * EUR is a 2-decimals currency, the value 1234 will result in EUR 12.34
+        * KWD is a 3-decimals currency, the value 1234 will result in KWD 1.234
+        * JPY is a zero-decimal currency, the value 1234 will result in JPY 1234
+
+        Type: int
+        """
+        return self.__discount_amount
+
+    @discount_amount.setter
+    def discount_amount(self, value: Optional[int]) -> None:
+        self.__discount_amount = value
+
+    @property
+    def product_brand(self) -> Optional[str]:
+        """
+        | The brand of the product.
+
+        Type: str
+        """
+        return self.__product_brand
+
+    @product_brand.setter
+    def product_brand(self, value: Optional[str]) -> None:
+        self.__product_brand = value
+
+    @property
+    def product_code(self) -> Optional[str]:
+        """
+        | Product or UPC Code
+
+        Type: str
+        """
+        return self.__product_code
+
+    @product_code.setter
+    def product_code(self, value: Optional[str]) -> None:
+        self.__product_code = value
+
+    @property
+    def product_name(self) -> Optional[str]:
+        """
+        | The name of the product.
+
+        Type: str
+        """
+        return self.__product_name
+
+    @product_name.setter
+    def product_name(self, value: Optional[str]) -> None:
+        self.__product_name = value
+
+    @property
+    def product_price(self) -> Optional[int]:
+        """
+        | The price of one unit of the product, the value should be zero or greater
+
+        Type: int
+        """
+        return self.__product_price
+
+    @product_price.setter
+    def product_price(self, value: Optional[int]) -> None:
+        self.__product_price = value
+
+    @property
+    def product_type(self) -> Optional[str]:
+        """
+        | Code used to classify items that are purchased
+
+        Type: str
+        """
+        return self.__product_type
+
+    @product_type.setter
+    def product_type(self, value: Optional[str]) -> None:
+        self.__product_type = value
+
+    @property
+    def quantity(self) -> Optional[int]:
+        """
+        | Quantity of the units being purchased, should be greater than zero Note: Must not be all spaces or all zeros
+
+        Type: int
+        """
+        return self.__quantity
+
+    @quantity.setter
+    def quantity(self, value: Optional[int]) -> None:
+        self.__quantity = value
+
+    @property
+    def tax_amount(self) -> Optional[int]:
+        """
+        | Amount in the smallest currency unit, i.e.:
+        
+        * EUR is a 2-decimals currency, the value 1234 will result in EUR 12.34
+        * KWD is a 3-decimals currency, the value 1234 will result in KWD 1.234
+        * JPY is a zero-decimal currency, the value 1234 will result in JPY 1234
+
+        Type: int
+        """
+        return self.__tax_amount
+
+    @tax_amount.setter
+    def tax_amount(self, value: Optional[int]) -> None:
+        self.__tax_amount = value
+
+    @property
+    def unit(self) -> Optional[str]:
+        """
+        | Indicates the line item unit of measure; for example: each, kit, pair, gallon, month, etc.
+
+        Type: str
+        """
+        return self.__unit
+
+    @unit.setter
+    def unit(self, value: Optional[str]) -> None:
+        self.__unit = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(OrderLineDetails, self).to_dictionary()
+        if self.discount_amount is not None:
+            dictionary['discountAmount'] = self.discount_amount
+        if self.product_brand is not None:
+            dictionary['productBrand'] = self.product_brand
+        if self.product_code is not None:
+            dictionary['productCode'] = self.product_code
+        if self.product_name is not None:
+            dictionary['productName'] = self.product_name
+        if self.product_price is not None:
+            dictionary['productPrice'] = self.product_price
+        if self.product_type is not None:
+            dictionary['productType'] = self.product_type
+        if self.quantity is not None:
+            dictionary['quantity'] = self.quantity
+        if self.tax_amount is not None:
+            dictionary['taxAmount'] = self.tax_amount
+        if self.unit is not None:
+            dictionary['unit'] = self.unit
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'OrderLineDetails':
+        super(OrderLineDetails, self).from_dictionary(dictionary)
+        if 'discountAmount' in dictionary:
+            self.discount_amount = dictionary['discountAmount']
+        if 'productBrand' in dictionary:
+            self.product_brand = dictionary['productBrand']
+        if 'productCode' in dictionary:
+            self.product_code = dictionary['productCode']
+        if 'productName' in dictionary:
+            self.product_name = dictionary['productName']
+        if 'productPrice' in dictionary:
+            self.product_price = dictionary['productPrice']
+        if 'productType' in dictionary:
+            self.product_type = dictionary['productType']
+        if 'quantity' in dictionary:
+            self.quantity = dictionary['quantity']
+        if 'taxAmount' in dictionary:
+            self.tax_amount = dictionary['taxAmount']
+        if 'unit' in dictionary:
+            self.unit = dictionary['unit']
+        return self