connect-sdk-python3 4.0.0__zip → 4.0.1__zip

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/fraugster_results.py

@@ -0,0 +1,58 @@
+# -*- 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 FraugsterResults(DataObject):
+
+    __fraud_investigation_points: Optional[str] = None
+    __fraud_score: Optional[int] = None
+
+    @property
+    def fraud_investigation_points(self) -> Optional[str]:
+        """
+        | Result of the Fraugster check
+        | Contains the investigation points used during the evaluation
+
+        Type: str
+        """
+        return self.__fraud_investigation_points
+
+    @fraud_investigation_points.setter
+    def fraud_investigation_points(self, value: Optional[str]) -> None:
+        self.__fraud_investigation_points = value
+
+    @property
+    def fraud_score(self) -> Optional[int]:
+        """
+        | Result of the Fraugster check
+        | Contains the overall Fraud score which is an integer between 0 and 99
+
+        Type: int
+        """
+        return self.__fraud_score
+
+    @fraud_score.setter
+    def fraud_score(self, value: Optional[int]) -> None:
+        self.__fraud_score = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(FraugsterResults, self).to_dictionary()
+        if self.fraud_investigation_points is not None:
+            dictionary['fraudInvestigationPoints'] = self.fraud_investigation_points
+        if self.fraud_score is not None:
+            dictionary['fraudScore'] = self.fraud_score
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'FraugsterResults':
+        super(FraugsterResults, self).from_dictionary(dictionary)
+        if 'fraudInvestigationPoints' in dictionary:
+            self.fraud_investigation_points = dictionary['fraudInvestigationPoints']
+        if 'fraudScore' in dictionary:
+            self.fraud_score = dictionary['fraudScore']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/frequency.py

@@ -0,0 +1,59 @@
+# -*- 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 Frequency(DataObject):
+    """
+    | The object containing the frequency and interval between recurring payments.
+    """
+
+    __interval: Optional[str] = None
+    __interval_frequency: Optional[int] = None
+
+    @property
+    def interval(self) -> Optional[str]:
+        """
+        | The interval between recurring payments specified as days, weeks, quarters, or years.
+
+        Type: str
+        """
+        return self.__interval
+
+    @interval.setter
+    def interval(self, value: Optional[str]) -> None:
+        self.__interval = value
+
+    @property
+    def interval_frequency(self) -> Optional[int]:
+        """
+        | The number of days, weeks, months, quarters, or years between recurring payments.
+
+        Type: int
+        """
+        return self.__interval_frequency
+
+    @interval_frequency.setter
+    def interval_frequency(self, value: Optional[int]) -> None:
+        self.__interval_frequency = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Frequency, self).to_dictionary()
+        if self.interval is not None:
+            dictionary['interval'] = self.interval
+        if self.interval_frequency is not None:
+            dictionary['intervalFrequency'] = self.interval_frequency
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Frequency':
+        super(Frequency, self).from_dictionary(dictionary)
+        if 'interval' in dictionary:
+            self.interval = dictionary['interval']
+        if 'intervalFrequency' in dictionary:
+            self.interval_frequency = dictionary['intervalFrequency']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/g_pay_three_d_secure.py

@@ -0,0 +1,137 @@
+# -*- 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.redirection_data import RedirectionData
+
+
+class GPayThreeDSecure(DataObject):
+
+    __challenge_canvas_size: Optional[str] = None
+    __challenge_indicator: Optional[str] = None
+    __exemption_request: Optional[str] = None
+    __redirection_data: Optional[RedirectionData] = None
+    __skip_authentication: Optional[bool] = None
+
+    @property
+    def challenge_canvas_size(self) -> Optional[str]:
+        """
+        | Dimensions of the challenge window that potentially will be displayed to the customer. The challenge content is formatted to appropriately render in this window to provide the best possible user experience.
+        | Preconfigured sizes are width x height in pixels of the window displayed in the customer browser window. Possible values are:
+        
+        * 250x400 (default)
+        * 390x400
+        * 500x600
+        * 600x400
+        * full-screen
+        
+        | .
+
+        Type: str
+        """
+        return self.__challenge_canvas_size
+
+    @challenge_canvas_size.setter
+    def challenge_canvas_size(self, value: Optional[str]) -> None:
+        self.__challenge_canvas_size = value
+
+    @property
+    def challenge_indicator(self) -> Optional[str]:
+        """
+        | Allows you to indicate if you want the customer to be challenged for extra security on this transaction.Possible values:
+        
+        * no-preference - You have no preference whether or not to challenge the customer (default)
+        * no-challenge-requested - you prefer the cardholder not to be challenged
+        * challenge-requested - you prefer the customer to be challenged
+        * challenge-required - you require the customer to be challenged
+
+        Type: str
+        """
+        return self.__challenge_indicator
+
+    @challenge_indicator.setter
+    def challenge_indicator(self, value: Optional[str]) -> None:
+        self.__challenge_indicator = value
+
+    @property
+    def exemption_request(self) -> Optional[str]:
+        """
+        | Type of strong customer authentication (SCA) exemption requested for this transaction. Possible values:
+        
+        * none - No exemption flagging is to be used of this transaction (Default).
+        * automatic - Our systems will determine the best possible exemption based on the transaction parameters and the risk scores.
+        * transaction-risk-analysis - You have determined that this transaction is of low risk and are willing to take the liability. Please note that your fraud rate needs to stay below thresholds to allow your use of this exemption.
+        * low-value - The value of the transaction is below 30 EUR. Please note that the issuer will still require every 5th low-value transaction pithing 24 hours to be strongly authenticated. The issuer will also keep track of the cumulative amount authorized on the card. When this exceeds 100 EUR strong customer authentication is also required.
+        * whitelist - You have been whitelisted by the customer at the issuer.
+
+        Type: str
+        """
+        return self.__exemption_request
+
+    @exemption_request.setter
+    def exemption_request(self, value: Optional[str]) -> None:
+        self.__exemption_request = value
+
+    @property
+    def redirection_data(self) -> Optional[RedirectionData]:
+        """
+        | Object containing browser specific redirection related data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.redirection_data.RedirectionData`
+        """
+        return self.__redirection_data
+
+    @redirection_data.setter
+    def redirection_data(self, value: Optional[RedirectionData]) -> None:
+        self.__redirection_data = value
+
+    @property
+    def skip_authentication(self) -> Optional[bool]:
+        """
+        * true = 3D Secure authentication will be skipped for this transaction. This setting should be used when isRecurring is set to true and recurringPaymentSequenceIndicator is set to recurring.
+        * false = 3D Secure authentication will not be skipped for this transaction.
+        
+        | Note: This is only possible if your account in our system is setup for 3D Secure authentication and if your configuration in our system allows you to override it per transaction.
+
+        Type: bool
+        """
+        return self.__skip_authentication
+
+    @skip_authentication.setter
+    def skip_authentication(self, value: Optional[bool]) -> None:
+        self.__skip_authentication = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GPayThreeDSecure, self).to_dictionary()
+        if self.challenge_canvas_size is not None:
+            dictionary['challengeCanvasSize'] = self.challenge_canvas_size
+        if self.challenge_indicator is not None:
+            dictionary['challengeIndicator'] = self.challenge_indicator
+        if self.exemption_request is not None:
+            dictionary['exemptionRequest'] = self.exemption_request
+        if self.redirection_data is not None:
+            dictionary['redirectionData'] = self.redirection_data.to_dictionary()
+        if self.skip_authentication is not None:
+            dictionary['skipAuthentication'] = self.skip_authentication
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GPayThreeDSecure':
+        super(GPayThreeDSecure, self).from_dictionary(dictionary)
+        if 'challengeCanvasSize' in dictionary:
+            self.challenge_canvas_size = dictionary['challengeCanvasSize']
+        if 'challengeIndicator' in dictionary:
+            self.challenge_indicator = dictionary['challengeIndicator']
+        if 'exemptionRequest' in dictionary:
+            self.exemption_request = dictionary['exemptionRequest']
+        if 'redirectionData' in dictionary:
+            if not isinstance(dictionary['redirectionData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['redirectionData']))
+            value = RedirectionData()
+            self.redirection_data = value.from_dictionary(dictionary['redirectionData'])
+        if 'skipAuthentication' in dictionary:
+            self.skip_authentication = dictionary['skipAuthentication']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/get_customer_details_request.py

@@ -0,0 +1,68 @@
+# -*- 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.key_value_pair import KeyValuePair
+
+
+class GetCustomerDetailsRequest(DataObject):
+    """
+    | Input for the retrieval of a customer's details.
+    """
+
+    __country_code: Optional[str] = None
+    __values: Optional[List[KeyValuePair]] = None
+
+    @property
+    def country_code(self) -> Optional[str]:
+        """
+        | The code of the country where the customer should reside.
+
+        Type: str
+        """
+        return self.__country_code
+
+    @country_code.setter
+    def country_code(self, value: Optional[str]) -> None:
+        self.__country_code = value
+
+    @property
+    def values(self) -> Optional[List[KeyValuePair]]:
+        """
+        | A list of keys with a value used to retrieve the details of a customer. Depending on the country code, different keys are required. These can be determined with a getPaymentProduct call and using payment product properties with the property usedForLookup set to true.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.key_value_pair.KeyValuePair`]
+        """
+        return self.__values
+
+    @values.setter
+    def values(self, value: Optional[List[KeyValuePair]]) -> None:
+        self.__values = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GetCustomerDetailsRequest, self).to_dictionary()
+        if self.country_code is not None:
+            dictionary['countryCode'] = self.country_code
+        if self.values is not None:
+            dictionary['values'] = []
+            for element in self.values:
+                if element is not None:
+                    dictionary['values'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GetCustomerDetailsRequest':
+        super(GetCustomerDetailsRequest, self).from_dictionary(dictionary)
+        if 'countryCode' in dictionary:
+            self.country_code = dictionary['countryCode']
+        if 'values' in dictionary:
+            if not isinstance(dictionary['values'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['values']))
+            self.values = []
+            for element in dictionary['values']:
+                value = KeyValuePair()
+                self.values.append(value.from_dictionary(element))
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/get_customer_details_response.py

@@ -0,0 +1,203 @@
+# -*- 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 GetCustomerDetailsResponse(DataObject):
+    """
+    | Output for the retrieval of a customer's details.
+    """
+
+    __city: Optional[str] = None
+    __country: Optional[str] = None
+    __email_address: Optional[str] = None
+    __first_name: Optional[str] = None
+    __fiscal_number: Optional[str] = None
+    __language_code: Optional[str] = None
+    __phone_number: Optional[str] = None
+    __street: Optional[str] = None
+    __surname: Optional[str] = None
+    __zip: Optional[str] = None
+
+    @property
+    def city(self) -> Optional[str]:
+        """
+        | The city in which the customer resides.
+
+        Type: str
+        """
+        return self.__city
+
+    @city.setter
+    def city(self, value: Optional[str]) -> None:
+        self.__city = value
+
+    @property
+    def country(self) -> Optional[str]:
+        """
+        | The country in which the customer resides.
+
+        Type: str
+        """
+        return self.__country
+
+    @country.setter
+    def country(self, value: Optional[str]) -> None:
+        self.__country = value
+
+    @property
+    def email_address(self) -> Optional[str]:
+        """
+        | The email address registered to the customer.
+
+        Type: str
+        """
+        return self.__email_address
+
+    @email_address.setter
+    def email_address(self, value: Optional[str]) -> None:
+        self.__email_address = value
+
+    @property
+    def first_name(self) -> Optional[str]:
+        """
+        | The first name of the customer
+
+        Type: str
+        """
+        return self.__first_name
+
+    @first_name.setter
+    def first_name(self, value: Optional[str]) -> None:
+        self.__first_name = value
+
+    @property
+    def fiscal_number(self) -> Optional[str]:
+        """
+        | The fiscal number (SSN) for the customer.
+
+        Type: str
+        """
+        return self.__fiscal_number
+
+    @fiscal_number.setter
+    def fiscal_number(self, value: Optional[str]) -> None:
+        self.__fiscal_number = value
+
+    @property
+    def language_code(self) -> Optional[str]:
+        """
+        | The code of the language used by the customer.
+
+        Type: str
+        """
+        return self.__language_code
+
+    @language_code.setter
+    def language_code(self, value: Optional[str]) -> None:
+        self.__language_code = value
+
+    @property
+    def phone_number(self) -> Optional[str]:
+        """
+        | The phone number registered to the customer.
+
+        Type: str
+        """
+        return self.__phone_number
+
+    @phone_number.setter
+    def phone_number(self, value: Optional[str]) -> None:
+        self.__phone_number = value
+
+    @property
+    def street(self) -> Optional[str]:
+        """
+        | The street on which the customer resides.
+
+        Type: str
+        """
+        return self.__street
+
+    @street.setter
+    def street(self, value: Optional[str]) -> None:
+        self.__street = value
+
+    @property
+    def surname(self) -> Optional[str]:
+        """
+        | The surname or family name of the customer.
+
+        Type: str
+        """
+        return self.__surname
+
+    @surname.setter
+    def surname(self, value: Optional[str]) -> None:
+        self.__surname = value
+
+    @property
+    def zip(self) -> Optional[str]:
+        """
+        | The ZIP or postal code for the area in which the customer resides.
+
+        Type: str
+        """
+        return self.__zip
+
+    @zip.setter
+    def zip(self, value: Optional[str]) -> None:
+        self.__zip = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GetCustomerDetailsResponse, self).to_dictionary()
+        if self.city is not None:
+            dictionary['city'] = self.city
+        if self.country is not None:
+            dictionary['country'] = self.country
+        if self.email_address is not None:
+            dictionary['emailAddress'] = self.email_address
+        if self.first_name is not None:
+            dictionary['firstName'] = self.first_name
+        if self.fiscal_number is not None:
+            dictionary['fiscalNumber'] = self.fiscal_number
+        if self.language_code is not None:
+            dictionary['languageCode'] = self.language_code
+        if self.phone_number is not None:
+            dictionary['phoneNumber'] = self.phone_number
+        if self.street is not None:
+            dictionary['street'] = self.street
+        if self.surname is not None:
+            dictionary['surname'] = self.surname
+        if self.zip is not None:
+            dictionary['zip'] = self.zip
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GetCustomerDetailsResponse':
+        super(GetCustomerDetailsResponse, self).from_dictionary(dictionary)
+        if 'city' in dictionary:
+            self.city = dictionary['city']
+        if 'country' in dictionary:
+            self.country = dictionary['country']
+        if 'emailAddress' in dictionary:
+            self.email_address = dictionary['emailAddress']
+        if 'firstName' in dictionary:
+            self.first_name = dictionary['firstName']
+        if 'fiscalNumber' in dictionary:
+            self.fiscal_number = dictionary['fiscalNumber']
+        if 'languageCode' in dictionary:
+            self.language_code = dictionary['languageCode']
+        if 'phoneNumber' in dictionary:
+            self.phone_number = dictionary['phoneNumber']
+        if 'street' in dictionary:
+            self.street = dictionary['street']
+        if 'surname' in dictionary:
+            self.surname = dictionary['surname']
+        if 'zip' in dictionary:
+            self.zip = dictionary['zip']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/get_hosted_checkout_response.py

@@ -0,0 +1,68 @@
+# -*- 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.created_payment_output import CreatedPaymentOutput
+
+
+class GetHostedCheckoutResponse(DataObject):
+
+    __created_payment_output: Optional[CreatedPaymentOutput] = None
+    __status: Optional[str] = None
+
+    @property
+    def created_payment_output(self) -> Optional[CreatedPaymentOutput]:
+        """
+        | When a payment has been created during the hosted checkout session this object will return the details.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.created_payment_output.CreatedPaymentOutput`
+        """
+        return self.__created_payment_output
+
+    @created_payment_output.setter
+    def created_payment_output(self, value: Optional[CreatedPaymentOutput]) -> None:
+        self.__created_payment_output = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | This is the status of the hosted checkout. Possible values are:
+        
+        * IN_PROGRESS - The checkout is still in progress and has not finished yet
+        * PAYMENT_CREATED - A payment has been created
+        * CANCELLED_BY_CONSUMER - If a customer cancels the payment on the payment product detail page of the MyCheckout hosted payment pages, the status will change to IN_PROGRESS. Since we understand you want to be aware of a customer cancelling the payment on the page we host for you, you can choose to receive the status CANCELLED_BY_CONSUMER instead of the status IN_PROGRESS. In order to receive the status CANCELLED_BY_CONSUMER, you need to have the returnCancelState flag enabled in the Create hosted checkout <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/hostedcheckouts/create.html> call.
+        * CLIENT_NOT_ELIGIBLE_FOR_SELECTED_PAYMENT_PRODUCT - With some payment products it might occur that the device of the user is not capable to complete the payment. If the Hosted Checkout Session was restricted to a single project that is not compatible to the user's device you will receive this Hosted Checkout status. This scenario applies to: Google Pay (Payment Product ID: 320).
+        
+        
+        | Please see Statuses <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/statuses.html> for a full overview of possible values.
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GetHostedCheckoutResponse, self).to_dictionary()
+        if self.created_payment_output is not None:
+            dictionary['createdPaymentOutput'] = self.created_payment_output.to_dictionary()
+        if self.status is not None:
+            dictionary['status'] = self.status
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GetHostedCheckoutResponse':
+        super(GetHostedCheckoutResponse, self).from_dictionary(dictionary)
+        if 'createdPaymentOutput' in dictionary:
+            if not isinstance(dictionary['createdPaymentOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['createdPaymentOutput']))
+            value = CreatedPaymentOutput()
+            self.created_payment_output = value.from_dictionary(dictionary['createdPaymentOutput'])
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/get_hosted_mandate_management_response.py

@@ -0,0 +1,67 @@
+# -*- 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.mandate_response import MandateResponse
+
+
+class GetHostedMandateManagementResponse(DataObject):
+
+    __mandate: Optional[MandateResponse] = None
+    __status: Optional[str] = None
+
+    @property
+    def mandate(self) -> Optional[MandateResponse]:
+        """
+        | When a mandate has been created during the hosted mandate management session this object will return the details.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.mandate_response.MandateResponse`
+        """
+        return self.__mandate
+
+    @mandate.setter
+    def mandate(self, value: Optional[MandateResponse]) -> None:
+        self.__mandate = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | This is the status of the hosted mandate management. Possible values are:
+        
+        * IN_PROGRESS - The session has been created, but no mandate has been created yet.
+        * MANDATE_CREATED - A mandate has been created, the customer might still need to sign the mandate.
+        * FAILED - There was an error while creating the mandate, the session can not continue.
+        * CANCELLED_BY_CONSUMER - The session was cancelled before a mandate was created
+        
+        | .
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GetHostedMandateManagementResponse, self).to_dictionary()
+        if self.mandate is not None:
+            dictionary['mandate'] = self.mandate.to_dictionary()
+        if self.status is not None:
+            dictionary['status'] = self.status
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GetHostedMandateManagementResponse':
+        super(GetHostedMandateManagementResponse, 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'])
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        return self