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

onlinepayments/sdk/domain/session_response.py

@@ -0,0 +1,114 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+
+
+class SessionResponse(DataObject):
+
+    __asset_url: Optional[str] = None
+    __client_api_url: Optional[str] = None
+    __client_session_id: Optional[str] = None
+    __customer_id: Optional[str] = None
+    __invalid_tokens: Optional[List[str]] = None
+
+    @property
+    def asset_url(self) -> Optional[str]:
+        """
+        | The datacenter-specific base url for assets. This value needs to be passed to the Client SDK to make sure that the client software connects to the right datacenter.
+
+        Type: str
+        """
+        return self.__asset_url
+
+    @asset_url.setter
+    def asset_url(self, value: Optional[str]) -> None:
+        self.__asset_url = value
+
+    @property
+    def client_api_url(self) -> Optional[str]:
+        """
+        | The datacenter-specific base url for client requests. This value needs to be passed to the Client SDK to make sure that the client software connects to the right datacenter.
+
+        Type: str
+        """
+        return self.__client_api_url
+
+    @client_api_url.setter
+    def client_api_url(self, value: Optional[str]) -> None:
+        self.__client_api_url = value
+
+    @property
+    def client_session_id(self) -> Optional[str]:
+        """
+        | The identifier of the session that has been created.
+
+        Type: str
+        """
+        return self.__client_session_id
+
+    @client_session_id.setter
+    def client_session_id(self, value: Optional[str]) -> None:
+        self.__client_session_id = value
+
+    @property
+    def customer_id(self) -> Optional[str]:
+        """
+        | The session is built up around the customer in the form of the customerId. All client APIs use this customerId in the URI to identify the customer.
+
+        Type: str
+        """
+        return self.__customer_id
+
+    @customer_id.setter
+    def customer_id(self, value: Optional[str]) -> None:
+        self.__customer_id = value
+
+    @property
+    def invalid_tokens(self) -> Optional[List[str]]:
+        """
+        Type: list[str]
+        """
+        return self.__invalid_tokens
+
+    @invalid_tokens.setter
+    def invalid_tokens(self, value: Optional[List[str]]) -> None:
+        self.__invalid_tokens = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SessionResponse, self).to_dictionary()
+        if self.asset_url is not None:
+            dictionary['assetUrl'] = self.asset_url
+        if self.client_api_url is not None:
+            dictionary['clientApiUrl'] = self.client_api_url
+        if self.client_session_id is not None:
+            dictionary['clientSessionId'] = self.client_session_id
+        if self.customer_id is not None:
+            dictionary['customerId'] = self.customer_id
+        if self.invalid_tokens is not None:
+            dictionary['invalidTokens'] = []
+            for element in self.invalid_tokens:
+                if element is not None:
+                    dictionary['invalidTokens'].append(element)
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SessionResponse':
+        super(SessionResponse, self).from_dictionary(dictionary)
+        if 'assetUrl' in dictionary:
+            self.asset_url = dictionary['assetUrl']
+        if 'clientApiUrl' in dictionary:
+            self.client_api_url = dictionary['clientApiUrl']
+        if 'clientSessionId' in dictionary:
+            self.client_session_id = dictionary['clientSessionId']
+        if 'customerId' in dictionary:
+            self.customer_id = dictionary['customerId']
+        if 'invalidTokens' in dictionary:
+            if not isinstance(dictionary['invalidTokens'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['invalidTokens']))
+            self.invalid_tokens = []
+            for element in dictionary['invalidTokens']:
+                self.invalid_tokens.append(element)
+        return self

onlinepayments/sdk/domain/shipping.py

@@ -0,0 +1,214 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .address_personal import AddressPersonal
+from .data_object import DataObject
+from .shipping_method import ShippingMethod
+
+
+class Shipping(DataObject):
+
+    __address: Optional[AddressPersonal] = None
+    __address_indicator: Optional[str] = None
+    __email_address: Optional[str] = None
+    __first_usage_date: Optional[str] = None
+    __is_first_usage: Optional[bool] = None
+    __method: Optional[ShippingMethod] = None
+    __shipping_cost: Optional[int] = None
+    __shipping_cost_tax: Optional[int] = None
+    __type: Optional[str] = None
+
+    @property
+    def address(self) -> Optional[AddressPersonal]:
+        """
+        | Object containing address information
+
+        Type: :class:`onlinepayments.sdk.domain.address_personal.AddressPersonal`
+        """
+        return self.__address
+
+    @address.setter
+    def address(self, value: Optional[AddressPersonal]) -> None:
+        self.__address = value
+
+    @property
+    def address_indicator(self) -> Optional[str]:
+        """
+        | Indicates shipping method chosen for the transaction. Possible values:
+        
+        * same-as-billing = the shipping address is the same as the billing address
+        * another-verified-address-on-file-with-merchant = the address used for shipping is another verified address of the customer that is on file with you
+        * different-than-billing = shipping address is different from the billing address
+        * ship-to-store = goods are shipped to a store (shipping address = store address)
+        * digital-goods = electronic delivery of digital goods
+        * travel-and-event-tickets-not-shipped = travel and/or event tickets that are not shipped
+        * other = other means of delivery
+
+        Type: str
+        """
+        return self.__address_indicator
+
+    @address_indicator.setter
+    def address_indicator(self, value: Optional[str]) -> None:
+        self.__address_indicator = value
+
+    @property
+    def email_address(self) -> Optional[str]:
+        """
+        | Email address linked to the shipping
+
+        Type: str
+        """
+        return self.__email_address
+
+    @email_address.setter
+    def email_address(self, value: Optional[str]) -> None:
+        self.__email_address = value
+
+    @property
+    def first_usage_date(self) -> Optional[str]:
+        """
+        | Date (YYYYMMDD) when the shipping details for this transaction were first used.
+
+        Type: str
+        """
+        return self.__first_usage_date
+
+    @first_usage_date.setter
+    def first_usage_date(self, value: Optional[str]) -> None:
+        self.__first_usage_date = value
+
+    @property
+    def is_first_usage(self) -> Optional[bool]:
+        """
+        | Indicator if this shipping address is used for the first time to ship an order
+        |
+        | true = the shipping details are used for the first time with this transaction
+        |
+        | false = the shipping details have been used for other transactions in the past
+
+        Type: bool
+        """
+        return self.__is_first_usage
+
+    @is_first_usage.setter
+    def is_first_usage(self, value: Optional[bool]) -> None:
+        self.__is_first_usage = value
+
+    @property
+    def method(self) -> Optional[ShippingMethod]:
+        """
+        | Object containing information regarding shipping method
+
+        Type: :class:`onlinepayments.sdk.domain.shipping_method.ShippingMethod`
+        """
+        return self.__method
+
+    @method.setter
+    def method(self, value: Optional[ShippingMethod]) -> None:
+        self.__method = value
+
+    @property
+    def shipping_cost(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.__shipping_cost
+
+    @shipping_cost.setter
+    def shipping_cost(self, value: Optional[int]) -> None:
+        self.__shipping_cost = value
+
+    @property
+    def shipping_cost_tax(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.__shipping_cost_tax
+
+    @shipping_cost_tax.setter
+    def shipping_cost_tax(self, value: Optional[int]) -> None:
+        self.__shipping_cost_tax = value
+
+    @property
+    def type(self) -> Optional[str]:
+        """
+        | Indicates the merchandise delivery timeframe. Possible values:
+        
+        * electronic = For electronic delivery (services or digital goods)
+        * same-day = For same day deliveries
+        * overnight = For overnight deliveries
+        * 2-day-or-more = For two day or more delivery time
+
+        Type: str
+        """
+        return self.__type
+
+    @type.setter
+    def type(self, value: Optional[str]) -> None:
+        self.__type = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Shipping, self).to_dictionary()
+        if self.address is not None:
+            dictionary['address'] = self.address.to_dictionary()
+        if self.address_indicator is not None:
+            dictionary['addressIndicator'] = self.address_indicator
+        if self.email_address is not None:
+            dictionary['emailAddress'] = self.email_address
+        if self.first_usage_date is not None:
+            dictionary['firstUsageDate'] = self.first_usage_date
+        if self.is_first_usage is not None:
+            dictionary['isFirstUsage'] = self.is_first_usage
+        if self.method is not None:
+            dictionary['method'] = self.method.to_dictionary()
+        if self.shipping_cost is not None:
+            dictionary['shippingCost'] = self.shipping_cost
+        if self.shipping_cost_tax is not None:
+            dictionary['shippingCostTax'] = self.shipping_cost_tax
+        if self.type is not None:
+            dictionary['type'] = self.type
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Shipping':
+        super(Shipping, self).from_dictionary(dictionary)
+        if 'address' in dictionary:
+            if not isinstance(dictionary['address'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['address']))
+            value = AddressPersonal()
+            self.address = value.from_dictionary(dictionary['address'])
+        if 'addressIndicator' in dictionary:
+            self.address_indicator = dictionary['addressIndicator']
+        if 'emailAddress' in dictionary:
+            self.email_address = dictionary['emailAddress']
+        if 'firstUsageDate' in dictionary:
+            self.first_usage_date = dictionary['firstUsageDate']
+        if 'isFirstUsage' in dictionary:
+            self.is_first_usage = dictionary['isFirstUsage']
+        if 'method' in dictionary:
+            if not isinstance(dictionary['method'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['method']))
+            value = ShippingMethod()
+            self.method = value.from_dictionary(dictionary['method'])
+        if 'shippingCost' in dictionary:
+            self.shipping_cost = dictionary['shippingCost']
+        if 'shippingCostTax' in dictionary:
+            self.shipping_cost_tax = dictionary['shippingCostTax']
+        if 'type' in dictionary:
+            self.type = dictionary['type']
+        return self

onlinepayments/sdk/domain/shipping_detail.py

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ShippingDetail(DataObject):
+
+    __shipping_cost: Optional[int] = None
+    __shipping_cost_tax: Optional[int] = None
+
+    @property
+    def shipping_cost(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.__shipping_cost
+
+    @shipping_cost.setter
+    def shipping_cost(self, value: Optional[int]) -> None:
+        self.__shipping_cost = value
+
+    @property
+    def shipping_cost_tax(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.__shipping_cost_tax
+
+    @shipping_cost_tax.setter
+    def shipping_cost_tax(self, value: Optional[int]) -> None:
+        self.__shipping_cost_tax = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ShippingDetail, self).to_dictionary()
+        if self.shipping_cost is not None:
+            dictionary['shippingCost'] = self.shipping_cost
+        if self.shipping_cost_tax is not None:
+            dictionary['shippingCostTax'] = self.shipping_cost_tax
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ShippingDetail':
+        super(ShippingDetail, self).from_dictionary(dictionary)
+        if 'shippingCost' in dictionary:
+            self.shipping_cost = dictionary['shippingCost']
+        if 'shippingCostTax' in dictionary:
+            self.shipping_cost_tax = dictionary['shippingCostTax']
+        return self

onlinepayments/sdk/domain/shipping_method.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ShippingMethod(DataObject):
+
+    __details: Optional[str] = None
+    __name: Optional[str] = None
+    __speed: Optional[int] = None
+    __type: Optional[str] = None
+
+    @property
+    def details(self) -> Optional[str]:
+        """
+        | Details about the shipping method
+
+        Type: str
+        """
+        return self.__details
+
+    @details.setter
+    def details(self, value: Optional[str]) -> None:
+        self.__details = value
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        | Name of the shipping method
+
+        Type: str
+        """
+        return self.__name
+
+    @name.setter
+    def name(self, value: Optional[str]) -> None:
+        self.__name = value
+
+    @property
+    def speed(self) -> Optional[int]:
+        """
+        | Number of hours to delivery
+
+        Type: int
+        """
+        return self.__speed
+
+    @speed.setter
+    def speed(self, value: Optional[int]) -> None:
+        self.__speed = value
+
+    @property
+    def type(self) -> Optional[str]:
+        """
+        | Shipping method type
+
+        Type: str
+        """
+        return self.__type
+
+    @type.setter
+    def type(self, value: Optional[str]) -> None:
+        self.__type = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ShippingMethod, self).to_dictionary()
+        if self.details is not None:
+            dictionary['details'] = self.details
+        if self.name is not None:
+            dictionary['name'] = self.name
+        if self.speed is not None:
+            dictionary['speed'] = self.speed
+        if self.type is not None:
+            dictionary['type'] = self.type
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ShippingMethod':
+        super(ShippingMethod, self).from_dictionary(dictionary)
+        if 'details' in dictionary:
+            self.details = dictionary['details']
+        if 'name' in dictionary:
+            self.name = dictionary['name']
+        if 'speed' in dictionary:
+            self.speed = dictionary['speed']
+        if 'type' in dictionary:
+            self.type = dictionary['type']
+        return self

onlinepayments/sdk/domain/shopping_cart.py

@@ -0,0 +1,155 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .amount_breakdown import AmountBreakdown
+from .data_object import DataObject
+from .gift_card_purchase import GiftCardPurchase
+from .line_item import LineItem
+
+
+class ShoppingCart(DataObject):
+
+    __amount_breakdown: Optional[List[AmountBreakdown]] = None
+    __gift_card_purchase: Optional[GiftCardPurchase] = None
+    __is_pre_order: Optional[bool] = None
+    __items: Optional[List[LineItem]] = None
+    __pre_order_item_availability_date: Optional[str] = None
+    __re_order_indicator: Optional[bool] = None
+
+    @property
+    def amount_breakdown(self) -> Optional[List[AmountBreakdown]]:
+        """
+        | Deprecated: Use order.shipping.shippingCost for shipping cost. Other amounts are not used. Determines how the total amount is split into amount types
+
+        Type: list[:class:`onlinepayments.sdk.domain.amount_breakdown.AmountBreakdown`]
+
+        Deprecated; Use order.shipping.shippingCost for shipping cost. Other amounts are not used. Determines how the total amount is split into amount types
+        """
+        return self.__amount_breakdown
+
+    @amount_breakdown.setter
+    def amount_breakdown(self, value: Optional[List[AmountBreakdown]]) -> None:
+        self.__amount_breakdown = value
+
+    @property
+    def gift_card_purchase(self) -> Optional[GiftCardPurchase]:
+        """
+        | Object containing information on purchased gift card(s)
+
+        Type: :class:`onlinepayments.sdk.domain.gift_card_purchase.GiftCardPurchase`
+        """
+        return self.__gift_card_purchase
+
+    @gift_card_purchase.setter
+    def gift_card_purchase(self, value: Optional[GiftCardPurchase]) -> None:
+        self.__gift_card_purchase = value
+
+    @property
+    def is_pre_order(self) -> Optional[bool]:
+        """
+        | The customer is pre-ordering one or more items
+
+        Type: bool
+        """
+        return self.__is_pre_order
+
+    @is_pre_order.setter
+    def is_pre_order(self, value: Optional[bool]) -> None:
+        self.__is_pre_order = value
+
+    @property
+    def items(self) -> Optional[List[LineItem]]:
+        """
+        | Shopping cart data
+
+        Type: list[:class:`onlinepayments.sdk.domain.line_item.LineItem`]
+        """
+        return self.__items
+
+    @items.setter
+    def items(self, value: Optional[List[LineItem]]) -> None:
+        self.__items = value
+
+    @property
+    def pre_order_item_availability_date(self) -> Optional[str]:
+        """
+        | Date (YYYYMMDD) when the preordered item becomes available
+
+        Type: str
+        """
+        return self.__pre_order_item_availability_date
+
+    @pre_order_item_availability_date.setter
+    def pre_order_item_availability_date(self, value: Optional[str]) -> None:
+        self.__pre_order_item_availability_date = value
+
+    @property
+    def re_order_indicator(self) -> Optional[bool]:
+        """
+        | Indicates whether the cardholder is reordering previously purchased item(s)
+        |
+        | true = the customer is re-ordering at least one of the items again
+        |
+        | false = this is the first time the customer is ordering these items
+
+        Type: bool
+        """
+        return self.__re_order_indicator
+
+    @re_order_indicator.setter
+    def re_order_indicator(self, value: Optional[bool]) -> None:
+        self.__re_order_indicator = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ShoppingCart, self).to_dictionary()
+        if self.amount_breakdown is not None:
+            dictionary['amountBreakdown'] = []
+            for element in self.amount_breakdown:
+                if element is not None:
+                    dictionary['amountBreakdown'].append(element.to_dictionary())
+        if self.gift_card_purchase is not None:
+            dictionary['giftCardPurchase'] = self.gift_card_purchase.to_dictionary()
+        if self.is_pre_order is not None:
+            dictionary['isPreOrder'] = self.is_pre_order
+        if self.items is not None:
+            dictionary['items'] = []
+            for element in self.items:
+                if element is not None:
+                    dictionary['items'].append(element.to_dictionary())
+        if self.pre_order_item_availability_date is not None:
+            dictionary['preOrderItemAvailabilityDate'] = self.pre_order_item_availability_date
+        if self.re_order_indicator is not None:
+            dictionary['reOrderIndicator'] = self.re_order_indicator
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ShoppingCart':
+        super(ShoppingCart, self).from_dictionary(dictionary)
+        if 'amountBreakdown' in dictionary:
+            if not isinstance(dictionary['amountBreakdown'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['amountBreakdown']))
+            self.amount_breakdown = []
+            for element in dictionary['amountBreakdown']:
+                value = AmountBreakdown()
+                self.amount_breakdown.append(value.from_dictionary(element))
+        if 'giftCardPurchase' in dictionary:
+            if not isinstance(dictionary['giftCardPurchase'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['giftCardPurchase']))
+            value = GiftCardPurchase()
+            self.gift_card_purchase = value.from_dictionary(dictionary['giftCardPurchase'])
+        if 'isPreOrder' in dictionary:
+            self.is_pre_order = dictionary['isPreOrder']
+        if 'items' in dictionary:
+            if not isinstance(dictionary['items'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['items']))
+            self.items = []
+            for element in dictionary['items']:
+                value = LineItem()
+                self.items.append(value.from_dictionary(element))
+        if 'preOrderItemAvailabilityDate' in dictionary:
+            self.pre_order_item_availability_date = dictionary['preOrderItemAvailabilityDate']
+        if 'reOrderIndicator' in dictionary:
+            self.re_order_indicator = dictionary['reOrderIndicator']
+        return self