connect-sdk-python3 4.0.0__zip → 4.0.1__zip

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/shipping.py

@@ -1,192 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.address_personal import AddressPersonal
-
-
-class Shipping(DataObject):
-    """
-    | Object containing information regarding shipping / delivery
-    """
-
-    __address: Optional[AddressPersonal] = None
-    __address_indicator: Optional[str] = None
-    __comments: Optional[str] = None
-    __email_address: Optional[str] = None
-    __first_usage_date: Optional[str] = None
-    __is_first_usage: Optional[bool] = None
-    __tracking_number: Optional[str] = None
-    __type: Optional[str] = None
-
-    @property
-    def address(self) -> Optional[AddressPersonal]:
-        """
-        | Object containing address information
-        
-        Type: :class:`worldline.connect.sdk.v1.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 comments(self) -> Optional[str]:
-        """
-        | Comments included during shipping
-        
-        Type: str
-        """
-        return self.__comments
-
-    @comments.setter
-    def comments(self, value: Optional[str]) -> None:
-        self.__comments = 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 tracking_number(self) -> Optional[str]:
-        """
-        | Shipment tracking number
-        
-        Type: str
-        """
-        return self.__tracking_number
-
-    @tracking_number.setter
-    def tracking_number(self, value: Optional[str]) -> None:
-        self.__tracking_number = 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 for payments that are processed by the GlobalCollect platform
-        * 2-day-or-more = For two day or more delivery time for payments that are processed by the Ogone platform
-        * priority = For prioritized deliveries for payments that are processed by the WL Online Payment Acceptance platform
-        * ground = For deliveries via ground for payments that are processed by the WL Online Payment Acceptance platform
-        * to-store = For deliveries to a store for payments that are processed by the WL Online Payment Acceptance platform
-        
-        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.comments is not None:
-            dictionary['comments'] = self.comments
-        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.tracking_number is not None:
-            dictionary['trackingNumber'] = self.tracking_number
-        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 'comments' in dictionary:
-            self.comments = dictionary['comments']
-        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 'trackingNumber' in dictionary:
-            self.tracking_number = dictionary['trackingNumber']
-        if 'type' in dictionary:
-            self.type = dictionary['type']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/shipping_risk_assessment.py

@@ -1,81 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.address_personal import AddressPersonal
-
-
-class ShippingRiskAssessment(DataObject):
-    """
-    | Object containing information regarding shipping / delivery
-    """
-
-    __address: Optional[AddressPersonal] = None
-    __comments: Optional[str] = None
-    __tracking_number: Optional[str] = None
-
-    @property
-    def address(self) -> Optional[AddressPersonal]:
-        """
-        | Object containing address information
-        
-        Type: :class:`worldline.connect.sdk.v1.domain.address_personal.AddressPersonal`
-        """
-        return self.__address
-
-    @address.setter
-    def address(self, value: Optional[AddressPersonal]) -> None:
-        self.__address = value
-
-    @property
-    def comments(self) -> Optional[str]:
-        """
-        | Comments included during shipping
-        
-        Type: str
-        """
-        return self.__comments
-
-    @comments.setter
-    def comments(self, value: Optional[str]) -> None:
-        self.__comments = value
-
-    @property
-    def tracking_number(self) -> Optional[str]:
-        """
-        | Shipment tracking number
-        
-        Type: str
-        """
-        return self.__tracking_number
-
-    @tracking_number.setter
-    def tracking_number(self, value: Optional[str]) -> None:
-        self.__tracking_number = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(ShippingRiskAssessment, self).to_dictionary()
-        if self.address is not None:
-            dictionary['address'] = self.address.to_dictionary()
-        if self.comments is not None:
-            dictionary['comments'] = self.comments
-        if self.tracking_number is not None:
-            dictionary['trackingNumber'] = self.tracking_number
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'ShippingRiskAssessment':
-        super(ShippingRiskAssessment, 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 'comments' in dictionary:
-            self.comments = dictionary['comments']
-        if 'trackingNumber' in dictionary:
-            self.tracking_number = dictionary['trackingNumber']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/shopping_cart.py

@@ -1,154 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import List, Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-from worldline.connect.sdk.v1.domain.amount_breakdown import AmountBreakdown
-from worldline.connect.sdk.v1.domain.gift_card_purchase import GiftCardPurchase
-from worldline.connect.sdk.v1.domain.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]]:
-        """
-        | Determines the type of the amount.
-        
-        Type: list[:class:`worldline.connect.sdk.v1.domain.amount_breakdown.AmountBreakdown`]
-        """
-        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:`worldline.connect.sdk.v1.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:`worldline.connect.sdk.v1.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

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/swift.py

@@ -1,201 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class Swift(DataObject):
-
-    __bic: Optional[str] = None
-    __category: Optional[str] = None
-    __chips_uid: Optional[str] = None
-    __extra_info: Optional[str] = None
-    __po_box_country: Optional[str] = None
-    __po_box_location: Optional[str] = None
-    __po_box_number: Optional[str] = None
-    __po_box_zip: Optional[str] = None
-    __routing_bic: Optional[str] = None
-    __services: Optional[str] = None
-
-    @property
-    def bic(self) -> Optional[str]:
-        """
-        | The BIC is the Business Identifier Code, also known as SWIFT or Bank Identifier code. It is a code with an internationally agreed format to Identify a specific bank or even branch. The BIC contains 8 or 11 positions: the first 4 contain the bank code, followed by the country code and location code.
-        
-        Type: str
-        """
-        return self.__bic
-
-    @bic.setter
-    def bic(self, value: Optional[str]) -> None:
-        self.__bic = value
-
-    @property
-    def category(self) -> Optional[str]:
-        """
-        | SWIFT category
-        
-        Type: str
-        """
-        return self.__category
-
-    @category.setter
-    def category(self, value: Optional[str]) -> None:
-        self.__category = value
-
-    @property
-    def chips_uid(self) -> Optional[str]:
-        """
-        | Clearing House Interbank Payments System (CHIPS) UID
-        | CHIPS is one half of the primary US network of large-value domestic and international payments.
-        
-        Type: str
-        """
-        return self.__chips_uid
-
-    @chips_uid.setter
-    def chips_uid(self, value: Optional[str]) -> None:
-        self.__chips_uid = value
-
-    @property
-    def extra_info(self) -> Optional[str]:
-        """
-        | SWIFT extra information
-        
-        Type: str
-        """
-        return self.__extra_info
-
-    @extra_info.setter
-    def extra_info(self, value: Optional[str]) -> None:
-        self.__extra_info = value
-
-    @property
-    def po_box_country(self) -> Optional[str]:
-        """
-        | Institution PO Box country
-        
-        Type: str
-        """
-        return self.__po_box_country
-
-    @po_box_country.setter
-    def po_box_country(self, value: Optional[str]) -> None:
-        self.__po_box_country = value
-
-    @property
-    def po_box_location(self) -> Optional[str]:
-        """
-        | Institution PO Box location
-        
-        Type: str
-        """
-        return self.__po_box_location
-
-    @po_box_location.setter
-    def po_box_location(self, value: Optional[str]) -> None:
-        self.__po_box_location = value
-
-    @property
-    def po_box_number(self) -> Optional[str]:
-        """
-        | Institution PO Box number
-        
-        Type: str
-        """
-        return self.__po_box_number
-
-    @po_box_number.setter
-    def po_box_number(self, value: Optional[str]) -> None:
-        self.__po_box_number = value
-
-    @property
-    def po_box_zip(self) -> Optional[str]:
-        """
-        | Institution PO Box ZIP
-        
-        Type: str
-        """
-        return self.__po_box_zip
-
-    @po_box_zip.setter
-    def po_box_zip(self, value: Optional[str]) -> None:
-        self.__po_box_zip = value
-
-    @property
-    def routing_bic(self) -> Optional[str]:
-        """
-        | Payment routing BIC
-        
-        Type: str
-        """
-        return self.__routing_bic
-
-    @routing_bic.setter
-    def routing_bic(self, value: Optional[str]) -> None:
-        self.__routing_bic = value
-
-    @property
-    def services(self) -> Optional[str]:
-        """
-        | SWIFT services
-        
-        Type: str
-        """
-        return self.__services
-
-    @services.setter
-    def services(self, value: Optional[str]) -> None:
-        self.__services = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(Swift, self).to_dictionary()
-        if self.bic is not None:
-            dictionary['bic'] = self.bic
-        if self.category is not None:
-            dictionary['category'] = self.category
-        if self.chips_uid is not None:
-            dictionary['chipsUID'] = self.chips_uid
-        if self.extra_info is not None:
-            dictionary['extraInfo'] = self.extra_info
-        if self.po_box_country is not None:
-            dictionary['poBoxCountry'] = self.po_box_country
-        if self.po_box_location is not None:
-            dictionary['poBoxLocation'] = self.po_box_location
-        if self.po_box_number is not None:
-            dictionary['poBoxNumber'] = self.po_box_number
-        if self.po_box_zip is not None:
-            dictionary['poBoxZip'] = self.po_box_zip
-        if self.routing_bic is not None:
-            dictionary['routingBic'] = self.routing_bic
-        if self.services is not None:
-            dictionary['services'] = self.services
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'Swift':
-        super(Swift, self).from_dictionary(dictionary)
-        if 'bic' in dictionary:
-            self.bic = dictionary['bic']
-        if 'category' in dictionary:
-            self.category = dictionary['category']
-        if 'chipsUID' in dictionary:
-            self.chips_uid = dictionary['chipsUID']
-        if 'extraInfo' in dictionary:
-            self.extra_info = dictionary['extraInfo']
-        if 'poBoxCountry' in dictionary:
-            self.po_box_country = dictionary['poBoxCountry']
-        if 'poBoxLocation' in dictionary:
-            self.po_box_location = dictionary['poBoxLocation']
-        if 'poBoxNumber' in dictionary:
-            self.po_box_number = dictionary['poBoxNumber']
-        if 'poBoxZip' in dictionary:
-            self.po_box_zip = dictionary['poBoxZip']
-        if 'routingBic' in dictionary:
-            self.routing_bic = dictionary['routingBic']
-        if 'services' in dictionary:
-            self.services = dictionary['services']
-        return self

connect-sdk-python3-4.0.0/worldline/connect/sdk/v1/domain/test_connection.py

@@ -1,38 +0,0 @@
-# -*- coding: utf-8 -*-
-#
-# This class was auto-generated from the API references found at
-# https://apireference.connect.worldline-solutions.com/
-#
-from typing import Optional
-
-from worldline.connect.sdk.domain.data_object import DataObject
-
-
-class TestConnection(DataObject):
-
-    __result: Optional[str] = None
-
-    @property
-    def result(self) -> Optional[str]:
-        """
-        | OK result on the connection to the payment engine.
-        
-        Type: str
-        """
-        return self.__result
-
-    @result.setter
-    def result(self, value: Optional[str]) -> None:
-        self.__result = value
-
-    def to_dictionary(self) -> dict:
-        dictionary = super(TestConnection, self).to_dictionary()
-        if self.result is not None:
-            dictionary['result'] = self.result
-        return dictionary
-
-    def from_dictionary(self, dictionary: dict) -> 'TestConnection':
-        super(TestConnection, self).from_dictionary(dictionary)
-        if 'result' in dictionary:
-            self.result = dictionary['result']
-        return self