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

onlinepayments/sdk/domain/get_iin_details_response.py

@@ -0,0 +1,450 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from datetime import date
+from typing import List, Optional
+
+from .data_object import DataObject
+from .iin_detail import IINDetail
+
+
+class GetIINDetailsResponse(DataObject):
+
+    __card_corporate_indicator: Optional[bool] = None
+    __card_effective_date: Optional[date] = None
+    __card_effective_date_indicator: Optional[bool] = None
+    __card_pan_type: Optional[str] = None
+    __card_product_code: Optional[str] = None
+    __card_product_name: Optional[str] = None
+    __card_product_usage_label: Optional[str] = None
+    __card_scheme: Optional[str] = None
+    __card_type: Optional[str] = None
+    __co_brands: Optional[List[IINDetail]] = None
+    __country_code: Optional[str] = None
+    __is_allowed_in_context: Optional[bool] = None
+    __issuer_code: Optional[str] = None
+    __issuer_name: Optional[str] = None
+    __issuer_region_code: Optional[str] = None
+    __issuing_country_code: Optional[str] = None
+    __pan_length_max: Optional[int] = None
+    __pan_length_min: Optional[int] = None
+    __pan_luhn_check: Optional[bool] = None
+    __payment_product_id: Optional[int] = None
+    __virtual_card_indicator: Optional[bool] = None
+
+    @property
+    def card_corporate_indicator(self) -> Optional[bool]:
+        """
+        | Indicates whether the card is an Enterprise / Commercial card or not
+
+        Type: bool
+        """
+        return self.__card_corporate_indicator
+
+    @card_corporate_indicator.setter
+    def card_corporate_indicator(self, value: Optional[bool]) -> None:
+        self.__card_corporate_indicator = value
+
+    @property
+    def card_effective_date(self) -> Optional[date]:
+        """
+        | The card effective date (YYYY-MM-DD)
+
+        Type: date
+        """
+        return self.__card_effective_date
+
+    @card_effective_date.setter
+    def card_effective_date(self, value: Optional[date]) -> None:
+        self.__card_effective_date = value
+
+    @property
+    def card_effective_date_indicator(self) -> Optional[bool]:
+        """
+        | Indicator of existence of a card effective date
+
+        Type: bool
+        """
+        return self.__card_effective_date_indicator
+
+    @card_effective_date_indicator.setter
+    def card_effective_date_indicator(self, value: Optional[bool]) -> None:
+        self.__card_effective_date_indicator = value
+
+    @property
+    def card_pan_type(self) -> Optional[str]:
+        """
+        | PAN type sent
+        
+        * ``dpan`` Digital PAN
+        * ``pan`` Real PAN
+
+        Type: str
+        """
+        return self.__card_pan_type
+
+    @card_pan_type.setter
+    def card_pan_type(self, value: Optional[str]) -> None:
+        self.__card_pan_type = value
+
+    @property
+    def card_product_code(self) -> Optional[str]:
+        """
+        | Product code of the card
+
+        Type: str
+        """
+        return self.__card_product_code
+
+    @card_product_code.setter
+    def card_product_code(self, value: Optional[str]) -> None:
+        self.__card_product_code = value
+
+    @property
+    def card_product_name(self) -> Optional[str]:
+        """
+        | Product name of the card
+
+        Type: str
+        """
+        return self.__card_product_name
+
+    @card_product_name.setter
+    def card_product_name(self, value: Optional[str]) -> None:
+        self.__card_product_name = value
+
+    @property
+    def card_product_usage_label(self) -> Optional[str]:
+        """
+        | Profile name of the card which is displayed on payment electronic ticket in accordance with MPADS requirements
+        
+        * ``commercial`` Business card
+        * ``credit`` Credit card
+        * ``debit`` Debit card
+        * ``prepaid`` Prepaid card
+
+        Type: str
+        """
+        return self.__card_product_usage_label
+
+    @card_product_usage_label.setter
+    def card_product_usage_label(self, value: Optional[str]) -> None:
+        self.__card_product_usage_label = value
+
+    @property
+    def card_scheme(self) -> Optional[str]:
+        """
+        | Network name associated with the card that is informational only and not to be coded against
+        
+        * ``AmericanExpress`` American Express scheme
+        * ``Bancontact`` Bancontact scheme
+        * ``Cb`` Cartes Bancaires scheme
+        * ``Cup`` China UnionPay scheme
+        * ``Dankort`` Dankort scheme
+        * ``DinersDiscover`` Diners Discover scheme
+        * ``Eftpos`` eftpos scheme
+        * ``Jcb`` Japan Credit Bureau scheme
+        * ``Mastercard`` Mastercard scheme
+        * ``Oney`` Oney scheme
+        * ``Uatp`` Universal Air Travel Plan scheme
+        * ``Visa`` Visa scheme
+
+        Type: str
+        """
+        return self.__card_scheme
+
+    @card_scheme.setter
+    def card_scheme(self, value: Optional[str]) -> None:
+        self.__card_scheme = value
+
+    @property
+    def card_type(self) -> Optional[str]:
+        """
+        | The card's type as categorised by the payment method. Possible values are:
+        
+        * Credit
+        * Debit
+        * Prepaid
+
+        Type: str
+        """
+        return self.__card_type
+
+    @card_type.setter
+    def card_type(self, value: Optional[str]) -> None:
+        self.__card_type = value
+
+    @property
+    def co_brands(self) -> Optional[List[IINDetail]]:
+        """
+        | List of IIN details
+
+        Type: list[:class:`onlinepayments.sdk.domain.iin_detail.IINDetail`]
+        """
+        return self.__co_brands
+
+    @co_brands.setter
+    def co_brands(self, value: Optional[List[IINDetail]]) -> None:
+        self.__co_brands = value
+
+    @property
+    def country_code(self) -> Optional[str]:
+        """
+        | The ISO 3166-1 alpha-2 country code of the card issuer. If we do not know the country of the card issuer, then the countryCode will return the value '99'.
+
+        Type: str
+        """
+        return self.__country_code
+
+    @country_code.setter
+    def country_code(self, value: Optional[str]) -> None:
+        self.__country_code = value
+
+    @property
+    def is_allowed_in_context(self) -> Optional[bool]:
+        """
+        | Populated only if you submitted a payment context.
+        
+        * true - The payment product is allowed in the submitted context.
+        * false - The payment product is not allowed in the submitted context. Note that in this case, none of the brands of the card will be allowed in the submitted context.
+
+        Type: bool
+        """
+        return self.__is_allowed_in_context
+
+    @is_allowed_in_context.setter
+    def is_allowed_in_context(self, value: Optional[bool]) -> None:
+        self.__is_allowed_in_context = value
+
+    @property
+    def issuer_code(self) -> Optional[str]:
+        """
+        | Issuer code of the card
+
+        Type: str
+        """
+        return self.__issuer_code
+
+    @issuer_code.setter
+    def issuer_code(self, value: Optional[str]) -> None:
+        self.__issuer_code = value
+
+    @property
+    def issuer_name(self) -> Optional[str]:
+        """
+        | Issuer name of the card
+
+        Type: str
+        """
+        return self.__issuer_name
+
+    @issuer_name.setter
+    def issuer_name(self, value: Optional[str]) -> None:
+        self.__issuer_name = value
+
+    @property
+    def issuer_region_code(self) -> Optional[str]:
+        """
+        | Region code of the card issuer
+        
+        * ``1`` USA: California, Hawaii, Nevada
+        * ``2`` USA: West except California, Hawaii, Nevada
+        * ``3`` USA: Central North
+        * ``4`` USA: Central South
+        * ``5`` USA: Great Lakes states
+        * ``6`` USA: South East
+        * ``7`` USA: Extreme North East
+        * ``8`` USA: North East
+        * ``9`` USA: Florida and Georgia
+        * ``a`` Canada
+        * ``b`` South America
+        * ``c`` Oceania and Asia
+        * ``d`` Europe
+        * ``e`` Africa and Middle East
+
+        Type: str
+        """
+        return self.__issuer_region_code
+
+    @issuer_region_code.setter
+    def issuer_region_code(self, value: Optional[str]) -> None:
+        self.__issuer_region_code = value
+
+    @property
+    def issuing_country_code(self) -> Optional[str]:
+        """
+        | ISO 3166-1 alpha-2 country code in which the card has been issued
+
+        Type: str
+        """
+        return self.__issuing_country_code
+
+    @issuing_country_code.setter
+    def issuing_country_code(self, value: Optional[str]) -> None:
+        self.__issuing_country_code = value
+
+    @property
+    def pan_length_max(self) -> Optional[int]:
+        """
+        | Maximum length of the PAN
+
+        Type: int
+        """
+        return self.__pan_length_max
+
+    @pan_length_max.setter
+    def pan_length_max(self, value: Optional[int]) -> None:
+        self.__pan_length_max = value
+
+    @property
+    def pan_length_min(self) -> Optional[int]:
+        """
+        | Minimal length of the PAN
+
+        Type: int
+        """
+        return self.__pan_length_min
+
+    @pan_length_min.setter
+    def pan_length_min(self, value: Optional[int]) -> None:
+        self.__pan_length_min = value
+
+    @property
+    def pan_luhn_check(self) -> Optional[bool]:
+        """
+        | Indicates whether the PAN is controlled with Lühn Key algorithm
+
+        Type: bool
+        """
+        return self.__pan_luhn_check
+
+    @pan_luhn_check.setter
+    def pan_luhn_check(self, value: Optional[bool]) -> None:
+        self.__pan_luhn_check = value
+
+    @property
+    def payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier - Please see Products documentation for a full overview of possible values.
+
+        Type: int
+        """
+        return self.__payment_product_id
+
+    @payment_product_id.setter
+    def payment_product_id(self, value: Optional[int]) -> None:
+        self.__payment_product_id = value
+
+    @property
+    def virtual_card_indicator(self) -> Optional[bool]:
+        """
+        | Indicates whether the card is a virtual card
+
+        Type: bool
+        """
+        return self.__virtual_card_indicator
+
+    @virtual_card_indicator.setter
+    def virtual_card_indicator(self, value: Optional[bool]) -> None:
+        self.__virtual_card_indicator = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GetIINDetailsResponse, self).to_dictionary()
+        if self.card_corporate_indicator is not None:
+            dictionary['cardCorporateIndicator'] = self.card_corporate_indicator
+        if self.card_effective_date is not None:
+            dictionary['cardEffectiveDate'] = DataObject.format_date(self.card_effective_date)
+        if self.card_effective_date_indicator is not None:
+            dictionary['cardEffectiveDateIndicator'] = self.card_effective_date_indicator
+        if self.card_pan_type is not None:
+            dictionary['cardPanType'] = self.card_pan_type
+        if self.card_product_code is not None:
+            dictionary['cardProductCode'] = self.card_product_code
+        if self.card_product_name is not None:
+            dictionary['cardProductName'] = self.card_product_name
+        if self.card_product_usage_label is not None:
+            dictionary['cardProductUsageLabel'] = self.card_product_usage_label
+        if self.card_scheme is not None:
+            dictionary['cardScheme'] = self.card_scheme
+        if self.card_type is not None:
+            dictionary['cardType'] = self.card_type
+        if self.co_brands is not None:
+            dictionary['coBrands'] = []
+            for element in self.co_brands:
+                if element is not None:
+                    dictionary['coBrands'].append(element.to_dictionary())
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.is_allowed_in_context is not None:
+            dictionary['isAllowedInContext'] = self.is_allowed_in_context
+        if self.issuer_code is not None:
+            dictionary['issuerCode'] = self.issuer_code
+        if self.issuer_name is not None:
+            dictionary['issuerName'] = self.issuer_name
+        if self.issuer_region_code is not None:
+            dictionary['issuerRegionCode'] = self.issuer_region_code
+        if self.issuing_country_code is not None:
+            dictionary['issuingCountryCode'] = self.issuing_country_code
+        if self.pan_length_max is not None:
+            dictionary['panLengthMax'] = self.pan_length_max
+        if self.pan_length_min is not None:
+            dictionary['panLengthMin'] = self.pan_length_min
+        if self.pan_luhn_check is not None:
+            dictionary['panLuhnCheck'] = self.pan_luhn_check
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        if self.virtual_card_indicator is not None:
+            dictionary['virtualCardIndicator'] = self.virtual_card_indicator
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GetIINDetailsResponse':
+        super(GetIINDetailsResponse, self).from_dictionary(dictionary)
+        if 'cardCorporateIndicator' in dictionary:
+            self.card_corporate_indicator = dictionary['cardCorporateIndicator']
+        if 'cardEffectiveDate' in dictionary:
+            self.card_effective_date = DataObject.parse_date(dictionary['cardEffectiveDate'])
+        if 'cardEffectiveDateIndicator' in dictionary:
+            self.card_effective_date_indicator = dictionary['cardEffectiveDateIndicator']
+        if 'cardPanType' in dictionary:
+            self.card_pan_type = dictionary['cardPanType']
+        if 'cardProductCode' in dictionary:
+            self.card_product_code = dictionary['cardProductCode']
+        if 'cardProductName' in dictionary:
+            self.card_product_name = dictionary['cardProductName']
+        if 'cardProductUsageLabel' in dictionary:
+            self.card_product_usage_label = dictionary['cardProductUsageLabel']
+        if 'cardScheme' in dictionary:
+            self.card_scheme = dictionary['cardScheme']
+        if 'cardType' in dictionary:
+            self.card_type = dictionary['cardType']
+        if 'coBrands' in dictionary:
+            if not isinstance(dictionary['coBrands'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['coBrands']))
+            self.co_brands = []
+            for element in dictionary['coBrands']:
+                value = IINDetail()
+                self.co_brands.append(value.from_dictionary(element))
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'isAllowedInContext' in dictionary:
+            self.is_allowed_in_context = dictionary['isAllowedInContext']
+        if 'issuerCode' in dictionary:
+            self.issuer_code = dictionary['issuerCode']
+        if 'issuerName' in dictionary:
+            self.issuer_name = dictionary['issuerName']
+        if 'issuerRegionCode' in dictionary:
+            self.issuer_region_code = dictionary['issuerRegionCode']
+        if 'issuingCountryCode' in dictionary:
+            self.issuing_country_code = dictionary['issuingCountryCode']
+        if 'panLengthMax' in dictionary:
+            self.pan_length_max = dictionary['panLengthMax']
+        if 'panLengthMin' in dictionary:
+            self.pan_length_min = dictionary['panLengthMin']
+        if 'panLuhnCheck' in dictionary:
+            self.pan_luhn_check = dictionary['panLuhnCheck']
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        if 'virtualCardIndicator' in dictionary:
+            self.virtual_card_indicator = dictionary['virtualCardIndicator']
+        return self

onlinepayments/sdk/domain/get_mandate_response.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .mandate_response import MandateResponse
+
+
+class GetMandateResponse(DataObject):
+
+    __mandate: Optional[MandateResponse] = None
+
+    @property
+    def mandate(self) -> Optional[MandateResponse]:
+        """
+        | Object containing the created mandate.
+
+        Type: :class:`onlinepayments.sdk.domain.mandate_response.MandateResponse`
+        """
+        return self.__mandate
+
+    @mandate.setter
+    def mandate(self, value: Optional[MandateResponse]) -> None:
+        self.__mandate = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GetMandateResponse, self).to_dictionary()
+        if self.mandate is not None:
+            dictionary['mandate'] = self.mandate.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GetMandateResponse':
+        super(GetMandateResponse, self).from_dictionary(dictionary)
+        if 'mandate' in dictionary:
+            if not isinstance(dictionary['mandate'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['mandate']))
+            value = MandateResponse()
+            self.mandate = value.from_dictionary(dictionary['mandate'])
+        return self

onlinepayments/sdk/domain/get_payment_product_groups_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 .payment_product_group import PaymentProductGroup
+
+
+class GetPaymentProductGroupsResponse(DataObject):
+
+    __payment_product_groups: Optional[List[PaymentProductGroup]] = None
+
+    @property
+    def payment_product_groups(self) -> Optional[List[PaymentProductGroup]]:
+        """
+        Type: list[:class:`onlinepayments.sdk.domain.payment_product_group.PaymentProductGroup`]
+        """
+        return self.__payment_product_groups
+
+    @payment_product_groups.setter
+    def payment_product_groups(self, value: Optional[List[PaymentProductGroup]]) -> None:
+        self.__payment_product_groups = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GetPaymentProductGroupsResponse, self).to_dictionary()
+        if self.payment_product_groups is not None:
+            dictionary['paymentProductGroups'] = []
+            for element in self.payment_product_groups:
+                if element is not None:
+                    dictionary['paymentProductGroups'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GetPaymentProductGroupsResponse':
+        super(GetPaymentProductGroupsResponse, self).from_dictionary(dictionary)
+        if 'paymentProductGroups' in dictionary:
+            if not isinstance(dictionary['paymentProductGroups'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['paymentProductGroups']))
+            self.payment_product_groups = []
+            for element in dictionary['paymentProductGroups']:
+                value = PaymentProductGroup()
+                self.payment_product_groups.append(value.from_dictionary(element))
+        return self

onlinepayments/sdk/domain/get_payment_products_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 .payment_product import PaymentProduct
+
+
+class GetPaymentProductsResponse(DataObject):
+
+    __payment_products: Optional[List[PaymentProduct]] = None
+
+    @property
+    def payment_products(self) -> Optional[List[PaymentProduct]]:
+        """
+        Type: list[:class:`onlinepayments.sdk.domain.payment_product.PaymentProduct`]
+        """
+        return self.__payment_products
+
+    @payment_products.setter
+    def payment_products(self, value: Optional[List[PaymentProduct]]) -> None:
+        self.__payment_products = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GetPaymentProductsResponse, self).to_dictionary()
+        if self.payment_products is not None:
+            dictionary['paymentProducts'] = []
+            for element in self.payment_products:
+                if element is not None:
+                    dictionary['paymentProducts'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GetPaymentProductsResponse':
+        super(GetPaymentProductsResponse, self).from_dictionary(dictionary)
+        if 'paymentProducts' in dictionary:
+            if not isinstance(dictionary['paymentProducts'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['paymentProducts']))
+            self.payment_products = []
+            for element in dictionary['paymentProducts']:
+                value = PaymentProduct()
+                self.payment_products.append(value.from_dictionary(element))
+        return self

onlinepayments/sdk/domain/get_privacy_policy_response.py

@@ -0,0 +1,37 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class GetPrivacyPolicyResponse(DataObject):
+
+    __html_content: Optional[str] = None
+
+    @property
+    def html_content(self) -> Optional[str]:
+        """
+        | HTML content to be displayed to the user.
+
+        Type: str
+        """
+        return self.__html_content
+
+    @html_content.setter
+    def html_content(self, value: Optional[str]) -> None:
+        self.__html_content = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GetPrivacyPolicyResponse, self).to_dictionary()
+        if self.html_content is not None:
+            dictionary['htmlContent'] = self.html_content
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GetPrivacyPolicyResponse':
+        super(GetPrivacyPolicyResponse, self).from_dictionary(dictionary)
+        if 'htmlContent' in dictionary:
+            self.html_content = dictionary['htmlContent']
+        return self

onlinepayments/sdk/domain/gift_card_purchase.py

@@ -0,0 +1,59 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+
+
+class GiftCardPurchase(DataObject):
+
+    __amount_of_money: Optional[AmountOfMoney] = None
+    __number_of_gift_cards: Optional[int] = 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 number_of_gift_cards(self) -> Optional[int]:
+        """
+        | Number of gift cards that are purchased through this transaction
+
+        Type: int
+        """
+        return self.__number_of_gift_cards
+
+    @number_of_gift_cards.setter
+    def number_of_gift_cards(self, value: Optional[int]) -> None:
+        self.__number_of_gift_cards = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GiftCardPurchase, self).to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.number_of_gift_cards is not None:
+            dictionary['numberOfGiftCards'] = self.number_of_gift_cards
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GiftCardPurchase':
+        super(GiftCardPurchase, 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 'numberOfGiftCards' in dictionary:
+            self.number_of_gift_cards = dictionary['numberOfGiftCards']
+        return self