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

onlinepayments/sdk/domain/rate_details.py

@@ -0,0 +1,109 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class RateDetails(DataObject):
+
+    __exchange_rate: Optional[float] = None
+    __inverted_exchange_rate: Optional[float] = None
+    __mark_up_rate: Optional[float] = None
+    __quotation_date_time: Optional[str] = None
+    __source: Optional[str] = None
+
+    @property
+    def exchange_rate(self) -> Optional[float]:
+        """
+        | Expressed as a percentage, applied to convert the original amount into the resulting amount without charge
+
+        Type: float
+        """
+        return self.__exchange_rate
+
+    @exchange_rate.setter
+    def exchange_rate(self, value: Optional[float]) -> None:
+        self.__exchange_rate = value
+
+    @property
+    def inverted_exchange_rate(self) -> Optional[float]:
+        """
+        | Exchange rate, expressed as a percentage, applied to convert the resulting amount into the original amount
+
+        Type: float
+        """
+        return self.__inverted_exchange_rate
+
+    @inverted_exchange_rate.setter
+    def inverted_exchange_rate(self, value: Optional[float]) -> None:
+        self.__inverted_exchange_rate = value
+
+    @property
+    def mark_up_rate(self) -> Optional[float]:
+        """
+        | The markup is the percentage added to the exchange rate by a provider when they sell you currency.
+
+        Type: float
+        """
+        return self.__mark_up_rate
+
+    @mark_up_rate.setter
+    def mark_up_rate(self, value: Optional[float]) -> None:
+        self.__mark_up_rate = value
+
+    @property
+    def quotation_date_time(self) -> Optional[str]:
+        """
+        | Date and time at which the exchange rate has been quoted
+
+        Type: str
+        """
+        return self.__quotation_date_time
+
+    @quotation_date_time.setter
+    def quotation_date_time(self, value: Optional[str]) -> None:
+        self.__quotation_date_time = value
+
+    @property
+    def source(self) -> Optional[str]:
+        """
+        | Indicates the exchange rate source name. The rate source is supplied for receipt printing purposes and to meet regulatory requirements where applicable
+
+        Type: str
+        """
+        return self.__source
+
+    @source.setter
+    def source(self, value: Optional[str]) -> None:
+        self.__source = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RateDetails, self).to_dictionary()
+        if self.exchange_rate is not None:
+            dictionary['exchangeRate'] = self.exchange_rate
+        if self.inverted_exchange_rate is not None:
+            dictionary['invertedExchangeRate'] = self.inverted_exchange_rate
+        if self.mark_up_rate is not None:
+            dictionary['markUpRate'] = self.mark_up_rate
+        if self.quotation_date_time is not None:
+            dictionary['quotationDateTime'] = self.quotation_date_time
+        if self.source is not None:
+            dictionary['source'] = self.source
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RateDetails':
+        super(RateDetails, self).from_dictionary(dictionary)
+        if 'exchangeRate' in dictionary:
+            self.exchange_rate = dictionary['exchangeRate']
+        if 'invertedExchangeRate' in dictionary:
+            self.inverted_exchange_rate = dictionary['invertedExchangeRate']
+        if 'markUpRate' in dictionary:
+            self.mark_up_rate = dictionary['markUpRate']
+        if 'quotationDateTime' in dictionary:
+            self.quotation_date_time = dictionary['quotationDateTime']
+        if 'source' in dictionary:
+            self.source = dictionary['source']
+        return self

onlinepayments/sdk/domain/reattempt_instructions.py

@@ -0,0 +1,82 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .reattempt_instructions_conditions import ReattemptInstructionsConditions
+
+
+class ReattemptInstructions(DataObject):
+
+    __conditions: Optional[ReattemptInstructionsConditions] = None
+    __frozen_period: Optional[int] = None
+    __indicator: Optional[str] = None
+
+    @property
+    def conditions(self) -> Optional[ReattemptInstructionsConditions]:
+        """
+        | Additional conditions to be met for reattempt. If the data is not provided by the acquirer, these fields are omitted from the response.
+
+        Type: :class:`onlinepayments.sdk.domain.reattempt_instructions_conditions.ReattemptInstructionsConditions`
+        """
+        return self.__conditions
+
+    @conditions.setter
+    def conditions(self, value: Optional[ReattemptInstructionsConditions]) -> None:
+        self.__conditions = value
+
+    @property
+    def frozen_period(self) -> Optional[int]:
+        """
+        | Hours to wait before next reattempt.
+
+        Type: int
+        """
+        return self.__frozen_period
+
+    @frozen_period.setter
+    def frozen_period(self, value: Optional[int]) -> None:
+        self.__frozen_period = value
+
+    @property
+    def indicator(self) -> Optional[str]:
+        """
+        | High-level use case. ``frozenPeriod`` and ``conditions``, when provided, only apply if indicator is one of:
+        
+        * ``retryLater``: retry with no change;
+        * ``updateBeforeRetry``: retry requires data updates; Otherwise:
+        * ``neverRetry``: the current payment authorization cannot be retried;
+        * ``dontStorePanCredentials``: no retry and no subsequent payment attempt or payment series using this PAN from credentials on file;
+
+        Type: str
+        """
+        return self.__indicator
+
+    @indicator.setter
+    def indicator(self, value: Optional[str]) -> None:
+        self.__indicator = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ReattemptInstructions, self).to_dictionary()
+        if self.conditions is not None:
+            dictionary['conditions'] = self.conditions.to_dictionary()
+        if self.frozen_period is not None:
+            dictionary['frozenPeriod'] = self.frozen_period
+        if self.indicator is not None:
+            dictionary['indicator'] = self.indicator
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ReattemptInstructions':
+        super(ReattemptInstructions, self).from_dictionary(dictionary)
+        if 'conditions' in dictionary:
+            if not isinstance(dictionary['conditions'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['conditions']))
+            value = ReattemptInstructionsConditions()
+            self.conditions = value.from_dictionary(dictionary['conditions'])
+        if 'frozenPeriod' in dictionary:
+            self.frozen_period = dictionary['frozenPeriod']
+        if 'indicator' in dictionary:
+            self.indicator = dictionary['indicator']
+        return self

onlinepayments/sdk/domain/reattempt_instructions_conditions.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class ReattemptInstructionsConditions(DataObject):
+
+    __max_attempts: Optional[int] = None
+    __max_delay: Optional[int] = None
+
+    @property
+    def max_attempts(self) -> Optional[int]:
+        """
+        | Max number of reattempts permitted.
+
+        Type: int
+        """
+        return self.__max_attempts
+
+    @max_attempts.setter
+    def max_attempts(self, value: Optional[int]) -> None:
+        self.__max_attempts = value
+
+    @property
+    def max_delay(self) -> Optional[int]:
+        """
+        | Max hours during which reattempt can be made.
+
+        Type: int
+        """
+        return self.__max_delay
+
+    @max_delay.setter
+    def max_delay(self, value: Optional[int]) -> None:
+        self.__max_delay = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ReattemptInstructionsConditions, self).to_dictionary()
+        if self.max_attempts is not None:
+            dictionary['maxAttempts'] = self.max_attempts
+        if self.max_delay is not None:
+            dictionary['maxDelay'] = self.max_delay
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ReattemptInstructionsConditions':
+        super(ReattemptInstructionsConditions, self).from_dictionary(dictionary)
+        if 'maxAttempts' in dictionary:
+            self.max_attempts = dictionary['maxAttempts']
+        if 'maxDelay' in dictionary:
+            self.max_delay = dictionary['maxDelay']
+        return self

onlinepayments/sdk/domain/redirect_data.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class RedirectData(DataObject):
+
+    __returnmac: Optional[str] = None
+    __redirect_url: Optional[str] = None
+
+    @property
+    def returnmac(self) -> Optional[str]:
+        """
+        | A Message Authentication Code (MAC) is used to authenticate the redirection back to merchant after the payment
+
+        Type: str
+        """
+        return self.__returnmac
+
+    @returnmac.setter
+    def returnmac(self, value: Optional[str]) -> None:
+        self.__returnmac = value
+
+    @property
+    def redirect_url(self) -> Optional[str]:
+        """
+        | The URL that the customer should be redirected to. Be sure to redirect using the GET method
+
+        Type: str
+        """
+        return self.__redirect_url
+
+    @redirect_url.setter
+    def redirect_url(self, value: Optional[str]) -> None:
+        self.__redirect_url = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RedirectData, self).to_dictionary()
+        if self.returnmac is not None:
+            dictionary['RETURNMAC'] = self.returnmac
+        if self.redirect_url is not None:
+            dictionary['redirectURL'] = self.redirect_url
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RedirectData':
+        super(RedirectData, self).from_dictionary(dictionary)
+        if 'RETURNMAC' in dictionary:
+            self.returnmac = dictionary['RETURNMAC']
+        if 'redirectURL' in dictionary:
+            self.redirect_url = dictionary['redirectURL']
+        return self