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

onlinepayments/sdk/domain/payment_product_field.py

@@ -0,0 +1,95 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_product_field_data_restrictions import PaymentProductFieldDataRestrictions
+from .payment_product_field_display_hints import PaymentProductFieldDisplayHints
+
+
+class PaymentProductField(DataObject):
+
+    __data_restrictions: Optional[PaymentProductFieldDataRestrictions] = None
+    __display_hints: Optional[PaymentProductFieldDisplayHints] = None
+    __id: Optional[str] = None
+    __type: Optional[str] = None
+
+    @property
+    def data_restrictions(self) -> Optional[PaymentProductFieldDataRestrictions]:
+        """
+        | Object containing data restrictions that apply to this field, like minimum and/or maximum length
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_field_data_restrictions.PaymentProductFieldDataRestrictions`
+        """
+        return self.__data_restrictions
+
+    @data_restrictions.setter
+    def data_restrictions(self, value: Optional[PaymentProductFieldDataRestrictions]) -> None:
+        self.__data_restrictions = value
+
+    @property
+    def display_hints(self) -> Optional[PaymentProductFieldDisplayHints]:
+        """
+        | Object containing display hints for this field, like the order, mask, preferred keyboard
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_field_display_hints.PaymentProductFieldDisplayHints`
+        """
+        return self.__display_hints
+
+    @display_hints.setter
+    def display_hints(self, value: Optional[PaymentProductFieldDisplayHints]) -> None:
+        self.__display_hints = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def type(self) -> Optional[str]:
+        """
+        Type: str
+        """
+        return self.__type
+
+    @type.setter
+    def type(self, value: Optional[str]) -> None:
+        self.__type = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductField, self).to_dictionary()
+        if self.data_restrictions is not None:
+            dictionary['dataRestrictions'] = self.data_restrictions.to_dictionary()
+        if self.display_hints is not None:
+            dictionary['displayHints'] = self.display_hints.to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.type is not None:
+            dictionary['type'] = self.type
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductField':
+        super(PaymentProductField, self).from_dictionary(dictionary)
+        if 'dataRestrictions' in dictionary:
+            if not isinstance(dictionary['dataRestrictions'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['dataRestrictions']))
+            value = PaymentProductFieldDataRestrictions()
+            self.data_restrictions = value.from_dictionary(dictionary['dataRestrictions'])
+        if 'displayHints' in dictionary:
+            if not isinstance(dictionary['displayHints'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['displayHints']))
+            value = PaymentProductFieldDisplayHints()
+            self.display_hints = value.from_dictionary(dictionary['displayHints'])
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'type' in dictionary:
+            self.type = dictionary['type']
+        return self

onlinepayments/sdk/domain/payment_product_field_data_restrictions.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_product_field_validators import PaymentProductFieldValidators
+
+
+class PaymentProductFieldDataRestrictions(DataObject):
+
+    __is_required: Optional[bool] = None
+    __validators: Optional[PaymentProductFieldValidators] = None
+
+    @property
+    def is_required(self) -> Optional[bool]:
+        """
+        * true - Indicates that this field is required
+        * false - Indicates that this field is optional
+
+        Type: bool
+        """
+        return self.__is_required
+
+    @is_required.setter
+    def is_required(self, value: Optional[bool]) -> None:
+        self.__is_required = value
+
+    @property
+    def validators(self) -> Optional[PaymentProductFieldValidators]:
+        """
+        | Object containing the details of the validations on the field
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_field_validators.PaymentProductFieldValidators`
+        """
+        return self.__validators
+
+    @validators.setter
+    def validators(self, value: Optional[PaymentProductFieldValidators]) -> None:
+        self.__validators = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductFieldDataRestrictions, self).to_dictionary()
+        if self.is_required is not None:
+            dictionary['isRequired'] = self.is_required
+        if self.validators is not None:
+            dictionary['validators'] = self.validators.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldDataRestrictions':
+        super(PaymentProductFieldDataRestrictions, self).from_dictionary(dictionary)
+        if 'isRequired' in dictionary:
+            self.is_required = dictionary['isRequired']
+        if 'validators' in dictionary:
+            if not isinstance(dictionary['validators'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['validators']))
+            value = PaymentProductFieldValidators()
+            self.validators = value.from_dictionary(dictionary['validators'])
+        return self

onlinepayments/sdk/domain/payment_product_field_display_element.py

@@ -0,0 +1,97 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProductFieldDisplayElement(DataObject):
+
+    __id: Optional[str] = None
+    __label: Optional[str] = None
+    __type: Optional[str] = None
+    __value: Optional[str] = None
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | The ID of the display element.
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def label(self) -> Optional[str]:
+        """
+        | The label of the display element.
+
+        Type: str
+        """
+        return self.__label
+
+    @label.setter
+    def label(self, value: Optional[str]) -> None:
+        self.__label = value
+
+    @property
+    def type(self) -> Optional[str]:
+        """
+        | The type of the display element. Indicates how the value should be presented. Possible values are:
+        
+        * STRING - as plain text
+        * CURRENCY - as an amount in cents displayed with a decimal separator and the currency of the payment
+        * PERCENTAGE - as a number with a percentage sign
+        * INTEGER - as an integer
+        * URI - as a link
+
+        Type: str
+        """
+        return self.__type
+
+    @type.setter
+    def type(self, value: Optional[str]) -> None:
+        self.__type = value
+
+    @property
+    def value(self) -> Optional[str]:
+        """
+        | the value of the display element.
+
+        Type: str
+        """
+        return self.__value
+
+    @value.setter
+    def value(self, value: Optional[str]) -> None:
+        self.__value = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductFieldDisplayElement, self).to_dictionary()
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.label is not None:
+            dictionary['label'] = self.label
+        if self.type is not None:
+            dictionary['type'] = self.type
+        if self.value is not None:
+            dictionary['value'] = self.value
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldDisplayElement':
+        super(PaymentProductFieldDisplayElement, self).from_dictionary(dictionary)
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'label' in dictionary:
+            self.label = dictionary['label']
+        if 'type' in dictionary:
+            self.type = dictionary['type']
+        if 'value' in dictionary:
+            self.value = dictionary['value']
+        return self

onlinepayments/sdk/domain/payment_product_field_display_hints.py

@@ -0,0 +1,218 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_product_field_form_element import PaymentProductFieldFormElement
+from .payment_product_field_tooltip import PaymentProductFieldTooltip
+
+
+class PaymentProductFieldDisplayHints(DataObject):
+
+    __always_show: Optional[bool] = None
+    __display_order: Optional[int] = None
+    __form_element: Optional[PaymentProductFieldFormElement] = None
+    __label: Optional[str] = None
+    __link: Optional[str] = None
+    __mask: Optional[str] = None
+    __obfuscate: Optional[bool] = None
+    __placeholder_label: Optional[str] = None
+    __preferred_input_type: Optional[str] = None
+    __tooltip: Optional[PaymentProductFieldTooltip] = None
+
+    @property
+    def always_show(self) -> Optional[bool]:
+        """
+        * true - Indicates that this field is advised to be captured to increase the success rates even-though it isn't marked as required. Please note that making the field required could hurt the success rates negatively. This boolean only indicates our advise to always show this field to the customer.
+        * false - Indicates that this field is not to be shown unless it is a required field.
+
+        Type: bool
+        """
+        return self.__always_show
+
+    @always_show.setter
+    def always_show(self, value: Optional[bool]) -> None:
+        self.__always_show = value
+
+    @property
+    def display_order(self) -> Optional[int]:
+        """
+        | The order in which the fields should be shown (ascending)
+
+        Type: int
+        """
+        return self.__display_order
+
+    @display_order.setter
+    def display_order(self, value: Optional[int]) -> None:
+        self.__display_order = value
+
+    @property
+    def form_element(self) -> Optional[PaymentProductFieldFormElement]:
+        """
+        | Object detailing the type of form element that should be used to present the field
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_field_form_element.PaymentProductFieldFormElement`
+        """
+        return self.__form_element
+
+    @form_element.setter
+    def form_element(self, value: Optional[PaymentProductFieldFormElement]) -> None:
+        self.__form_element = value
+
+    @property
+    def label(self) -> Optional[str]:
+        """
+        | Label/Name of the field to be used in the user interface
+
+        Type: str
+        """
+        return self.__label
+
+    @label.setter
+    def label(self, value: Optional[str]) -> None:
+        self.__label = value
+
+    @property
+    def link(self) -> Optional[str]:
+        """
+        | Deprecated: This field is not used by any payment product Link that should be used to replace the '{link}' variable in the label.
+
+        Type: str
+
+        Deprecated; Deprecated
+        """
+        return self.__link
+
+    @link.setter
+    def link(self, value: Optional[str]) -> None:
+        self.__link = value
+
+    @property
+    def mask(self) -> Optional[str]:
+        """
+        | A mask that can be used in the input field. You can use it to inject additional characters to provide a better user experience and to restrict the accepted character set (illegal characters will be ignored during typing).
+        
+        * is used for wildcards (and also chars) 9 is used for numbers Everything outside {{ and }} is used as-is.
+
+        Type: str
+        """
+        return self.__mask
+
+    @mask.setter
+    def mask(self, value: Optional[str]) -> None:
+        self.__mask = value
+
+    @property
+    def obfuscate(self) -> Optional[bool]:
+        """
+        * true - The data in this field should be obfuscated as it is entered, just like a password field
+        * false - The data in this field does not need to be obfuscated
+
+        Type: bool
+        """
+        return self.__obfuscate
+
+    @obfuscate.setter
+    def obfuscate(self, value: Optional[bool]) -> None:
+        self.__obfuscate = value
+
+    @property
+    def placeholder_label(self) -> Optional[str]:
+        """
+        | A placeholder value for the form element
+
+        Type: str
+        """
+        return self.__placeholder_label
+
+    @placeholder_label.setter
+    def placeholder_label(self, value: Optional[str]) -> None:
+        self.__placeholder_label = value
+
+    @property
+    def preferred_input_type(self) -> Optional[str]:
+        """
+        | The type of keyboard that can best be used to fill out the value of this field. Possible values are:
+        
+        * PhoneNumberKeyboard - Keyboard that is normally used to enter phone numbers
+        * StringKeyboard - Keyboard that is used to enter strings
+        * IntegerKeyboard - Keyboard that is used to enter only numerical values
+        * EmailAddressKeyboard - Keyboard that allows easier entry of email addresses
+
+        Type: str
+        """
+        return self.__preferred_input_type
+
+    @preferred_input_type.setter
+    def preferred_input_type(self, value: Optional[str]) -> None:
+        self.__preferred_input_type = value
+
+    @property
+    def tooltip(self) -> Optional[PaymentProductFieldTooltip]:
+        """
+        | Object that contains an optional tooltip to assist the customer
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_field_tooltip.PaymentProductFieldTooltip`
+        """
+        return self.__tooltip
+
+    @tooltip.setter
+    def tooltip(self, value: Optional[PaymentProductFieldTooltip]) -> None:
+        self.__tooltip = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductFieldDisplayHints, self).to_dictionary()
+        if self.always_show is not None:
+            dictionary['alwaysShow'] = self.always_show
+        if self.display_order is not None:
+            dictionary['displayOrder'] = self.display_order
+        if self.form_element is not None:
+            dictionary['formElement'] = self.form_element.to_dictionary()
+        if self.label is not None:
+            dictionary['label'] = self.label
+        if self.link is not None:
+            dictionary['link'] = self.link
+        if self.mask is not None:
+            dictionary['mask'] = self.mask
+        if self.obfuscate is not None:
+            dictionary['obfuscate'] = self.obfuscate
+        if self.placeholder_label is not None:
+            dictionary['placeholderLabel'] = self.placeholder_label
+        if self.preferred_input_type is not None:
+            dictionary['preferredInputType'] = self.preferred_input_type
+        if self.tooltip is not None:
+            dictionary['tooltip'] = self.tooltip.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldDisplayHints':
+        super(PaymentProductFieldDisplayHints, self).from_dictionary(dictionary)
+        if 'alwaysShow' in dictionary:
+            self.always_show = dictionary['alwaysShow']
+        if 'displayOrder' in dictionary:
+            self.display_order = dictionary['displayOrder']
+        if 'formElement' in dictionary:
+            if not isinstance(dictionary['formElement'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['formElement']))
+            value = PaymentProductFieldFormElement()
+            self.form_element = value.from_dictionary(dictionary['formElement'])
+        if 'label' in dictionary:
+            self.label = dictionary['label']
+        if 'link' in dictionary:
+            self.link = dictionary['link']
+        if 'mask' in dictionary:
+            self.mask = dictionary['mask']
+        if 'obfuscate' in dictionary:
+            self.obfuscate = dictionary['obfuscate']
+        if 'placeholderLabel' in dictionary:
+            self.placeholder_label = dictionary['placeholderLabel']
+        if 'preferredInputType' in dictionary:
+            self.preferred_input_type = dictionary['preferredInputType']
+        if 'tooltip' in dictionary:
+            if not isinstance(dictionary['tooltip'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['tooltip']))
+            value = PaymentProductFieldTooltip()
+            self.tooltip = value.from_dictionary(dictionary['tooltip'])
+        return self

onlinepayments/sdk/domain/payment_product_field_form_element.py

@@ -0,0 +1,72 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .data_object import DataObject
+from .value_mapping_element import ValueMappingElement
+
+
+class PaymentProductFieldFormElement(DataObject):
+
+    __type: Optional[str] = None
+    __value_mapping: Optional[List[ValueMappingElement]] = None
+
+    @property
+    def type(self) -> Optional[str]:
+        """
+        | Type of form element to be used. The following types can be returned:
+        
+        * text - A normal text input field
+        * list - A list of values that the customer needs to choose from, is detailed in the valueMapping array
+        * currency - Currency fields should be split into two fields, with the second one being specifically for the cents
+        * boolean - Boolean fields should offer the customer a choice, like accepting the terms and conditions of a product.
+        * date - let the customer pick a date.
+
+        Type: str
+        """
+        return self.__type
+
+    @type.setter
+    def type(self, value: Optional[str]) -> None:
+        self.__type = value
+
+    @property
+    def value_mapping(self) -> Optional[List[ValueMappingElement]]:
+        """
+        | Deprecated: This field is not used by any payment product
+
+        Type: list[:class:`onlinepayments.sdk.domain.value_mapping_element.ValueMappingElement`]
+
+        Deprecated; This field is not used by any payment product
+        """
+        return self.__value_mapping
+
+    @value_mapping.setter
+    def value_mapping(self, value: Optional[List[ValueMappingElement]]) -> None:
+        self.__value_mapping = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductFieldFormElement, self).to_dictionary()
+        if self.type is not None:
+            dictionary['type'] = self.type
+        if self.value_mapping is not None:
+            dictionary['valueMapping'] = []
+            for element in self.value_mapping:
+                if element is not None:
+                    dictionary['valueMapping'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldFormElement':
+        super(PaymentProductFieldFormElement, self).from_dictionary(dictionary)
+        if 'type' in dictionary:
+            self.type = dictionary['type']
+        if 'valueMapping' in dictionary:
+            if not isinstance(dictionary['valueMapping'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['valueMapping']))
+            self.value_mapping = []
+            for element in dictionary['valueMapping']:
+                value = ValueMappingElement()
+                self.value_mapping.append(value.from_dictionary(element))
+        return self

onlinepayments/sdk/domain/payment_product_field_tooltip.py

@@ -0,0 +1,57 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProductFieldTooltip(DataObject):
+
+    __image: Optional[str] = None
+    __label: Optional[str] = None
+
+    @property
+    def image(self) -> Optional[str]:
+        """
+        | Deprecated: This field is not used by any payment product Relative URL that can be used to retrieve an image for the tooltip image.
+
+        Type: str
+
+        Deprecated; This field is not used by any payment product Relative URL that can be used to retrieve an image for the tooltip image.
+        """
+        return self.__image
+
+    @image.setter
+    def image(self, value: Optional[str]) -> None:
+        self.__image = value
+
+    @property
+    def label(self) -> Optional[str]:
+        """
+        | A text explaining the field in more detail. This is meant to be used for displaying to the customer.
+
+        Type: str
+        """
+        return self.__label
+
+    @label.setter
+    def label(self, value: Optional[str]) -> None:
+        self.__label = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProductFieldTooltip, self).to_dictionary()
+        if self.image is not None:
+            dictionary['image'] = self.image
+        if self.label is not None:
+            dictionary['label'] = self.label
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProductFieldTooltip':
+        super(PaymentProductFieldTooltip, self).from_dictionary(dictionary)
+        if 'image' in dictionary:
+            self.image = dictionary['image']
+        if 'label' in dictionary:
+            self.label = dictionary['label']
+        return self