connect-sdk-python3 3.47.0__zip → 4.0.1__zip

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

@@ -0,0 +1,38 @@
+# -*- 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 RegularExpressionValidator(DataObject):
+
+    __regular_expression: Optional[str] = None
+
+    @property
+    def regular_expression(self) -> Optional[str]:
+        """
+        | Contains the regular expression that the value of the field needs to be validated against
+
+        Type: str
+        """
+        return self.__regular_expression
+
+    @regular_expression.setter
+    def regular_expression(self, value: Optional[str]) -> None:
+        self.__regular_expression = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RegularExpressionValidator, self).to_dictionary()
+        if self.regular_expression is not None:
+            dictionary['regularExpression'] = self.regular_expression
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RegularExpressionValidator':
+        super(RegularExpressionValidator, self).from_dictionary(dictionary)
+        if 'regularExpression' in dictionary:
+            self.regular_expression = dictionary['regularExpression']
+        return self

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

@@ -0,0 +1,113 @@
+# -*- 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.retail_decisions_cc_fraud_check_output import RetailDecisionsCCFraudCheckOutput
+from worldline.connect.sdk.v1.domain.validation_bank_account_output import ValidationBankAccountOutput
+
+
+class ResultDoRiskAssessment(DataObject):
+
+    __category: Optional[str] = None
+    __result: Optional[str] = None
+    __retaildecisions_cc_fraud_check_output: Optional[RetailDecisionsCCFraudCheckOutput] = None
+    __validation_bank_account_output: Optional[ValidationBankAccountOutput] = None
+
+    @property
+    def category(self) -> Optional[str]:
+        """
+        | The Risk Services category with the following possible values:
+        
+        * retaildecisionsCCFraudCheck - checks performed by Retail Decisions
+        * globalcollectBlacklistCheckCC - Checked against the blacklist on the GlobalCollect platform
+        * authorizationCheck - 0$ auth card account validation check
+        * ddFraudCheck - Check performed for German market via InterCard
+        * validationbankAccount - Bank account details are algorithmically checked if they could exist
+        * globalcollectBlacklistCheckDD - Checked against the blacklist on the GlobalCollect platform
+
+        Type: str
+        """
+        return self.__category
+
+    @category.setter
+    def category(self, value: Optional[str]) -> None:
+        self.__category = value
+
+    @property
+    def result(self) -> Optional[str]:
+        """
+        | Risk service result with the following possible results:
+        
+        * accepted - Based on the checks performed the transaction can be accepted
+        * challenged - Based on the checks performed the transaction should be manually reviewed
+        * denied - Based on the checks performed the transaction should be rejected
+        * no-advice - No fraud check was requested/performed
+        * error - The fraud check resulted in an error and the fraud check was thus not performed
+
+        Type: str
+        """
+        return self.__result
+
+    @result.setter
+    def result(self, value: Optional[str]) -> None:
+        self.__result = value
+
+    @property
+    def retaildecisions_cc_fraud_check_output(self) -> Optional[RetailDecisionsCCFraudCheckOutput]:
+        """
+        | Object containing the results of the fraud checks performed by Retail Decisions
+
+        Type: :class:`worldline.connect.sdk.v1.domain.retail_decisions_cc_fraud_check_output.RetailDecisionsCCFraudCheckOutput`
+        """
+        return self.__retaildecisions_cc_fraud_check_output
+
+    @retaildecisions_cc_fraud_check_output.setter
+    def retaildecisions_cc_fraud_check_output(self, value: Optional[RetailDecisionsCCFraudCheckOutput]) -> None:
+        self.__retaildecisions_cc_fraud_check_output = value
+
+    @property
+    def validation_bank_account_output(self) -> Optional[ValidationBankAccountOutput]:
+        """
+        | Object containing the results of the fraud checks performed on the bank account data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.validation_bank_account_output.ValidationBankAccountOutput`
+        """
+        return self.__validation_bank_account_output
+
+    @validation_bank_account_output.setter
+    def validation_bank_account_output(self, value: Optional[ValidationBankAccountOutput]) -> None:
+        self.__validation_bank_account_output = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(ResultDoRiskAssessment, self).to_dictionary()
+        if self.category is not None:
+            dictionary['category'] = self.category
+        if self.result is not None:
+            dictionary['result'] = self.result
+        if self.retaildecisions_cc_fraud_check_output is not None:
+            dictionary['retaildecisionsCCFraudCheckOutput'] = self.retaildecisions_cc_fraud_check_output.to_dictionary()
+        if self.validation_bank_account_output is not None:
+            dictionary['validationBankAccountOutput'] = self.validation_bank_account_output.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'ResultDoRiskAssessment':
+        super(ResultDoRiskAssessment, self).from_dictionary(dictionary)
+        if 'category' in dictionary:
+            self.category = dictionary['category']
+        if 'result' in dictionary:
+            self.result = dictionary['result']
+        if 'retaildecisionsCCFraudCheckOutput' in dictionary:
+            if not isinstance(dictionary['retaildecisionsCCFraudCheckOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['retaildecisionsCCFraudCheckOutput']))
+            value = RetailDecisionsCCFraudCheckOutput()
+            self.retaildecisions_cc_fraud_check_output = value.from_dictionary(dictionary['retaildecisionsCCFraudCheckOutput'])
+        if 'validationBankAccountOutput' in dictionary:
+            if not isinstance(dictionary['validationBankAccountOutput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['validationBankAccountOutput']))
+            value = ValidationBankAccountOutput()
+            self.validation_bank_account_output = value.from_dictionary(dictionary['validationBankAccountOutput'])
+        return self

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

@@ -0,0 +1,74 @@
+# -*- 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 RetailDecisionsCCFraudCheckOutput(DataObject):
+
+    __fraud_code: Optional[str] = None
+    __fraud_neural: Optional[str] = None
+    __fraud_rcf: Optional[str] = None
+
+    @property
+    def fraud_code(self) -> Optional[str]:
+        """
+        | Provides additional information about the fraud result
+
+        Type: str
+        """
+        return self.__fraud_code
+
+    @fraud_code.setter
+    def fraud_code(self, value: Optional[str]) -> None:
+        self.__fraud_code = value
+
+    @property
+    def fraud_neural(self) -> Optional[str]:
+        """
+        | The raw score returned by the Neural check returned by the evaluation of the transaction
+
+        Type: str
+        """
+        return self.__fraud_neural
+
+    @fraud_neural.setter
+    def fraud_neural(self, value: Optional[str]) -> None:
+        self.__fraud_neural = value
+
+    @property
+    def fraud_rcf(self) -> Optional[str]:
+        """
+        | List of RuleCategoryFlags as setup in the Retail Decisions system that lead to the result
+
+        Type: str
+        """
+        return self.__fraud_rcf
+
+    @fraud_rcf.setter
+    def fraud_rcf(self, value: Optional[str]) -> None:
+        self.__fraud_rcf = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RetailDecisionsCCFraudCheckOutput, self).to_dictionary()
+        if self.fraud_code is not None:
+            dictionary['fraudCode'] = self.fraud_code
+        if self.fraud_neural is not None:
+            dictionary['fraudNeural'] = self.fraud_neural
+        if self.fraud_rcf is not None:
+            dictionary['fraudRCF'] = self.fraud_rcf
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RetailDecisionsCCFraudCheckOutput':
+        super(RetailDecisionsCCFraudCheckOutput, self).from_dictionary(dictionary)
+        if 'fraudCode' in dictionary:
+            self.fraud_code = dictionary['fraudCode']
+        if 'fraudNeural' in dictionary:
+            self.fraud_neural = dictionary['fraudNeural']
+        if 'fraudRCF' in dictionary:
+            self.fraud_rcf = dictionary['fraudRCF']
+        return self

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

@@ -0,0 +1,101 @@
+# -*- 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.fraud_fields import FraudFields
+from worldline.connect.sdk.v1.domain.merchant_risk_assessment import MerchantRiskAssessment
+from worldline.connect.sdk.v1.domain.order_risk_assessment import OrderRiskAssessment
+
+
+class RiskAssessment(DataObject):
+
+    __fraud_fields: Optional[FraudFields] = None
+    __merchant: Optional[MerchantRiskAssessment] = None
+    __order: Optional[OrderRiskAssessment] = None
+    __payment_product_id: Optional[int] = None
+
+    @property
+    def fraud_fields(self) -> Optional[FraudFields]:
+        """
+        | Object containing additional data that will be used to assess the risk of fraud
+
+        Type: :class:`worldline.connect.sdk.v1.domain.fraud_fields.FraudFields`
+        """
+        return self.__fraud_fields
+
+    @fraud_fields.setter
+    def fraud_fields(self, value: Optional[FraudFields]) -> None:
+        self.__fraud_fields = value
+
+    @property
+    def merchant(self) -> Optional[MerchantRiskAssessment]:
+        """
+        Type: :class:`worldline.connect.sdk.v1.domain.merchant_risk_assessment.MerchantRiskAssessment`
+        """
+        return self.__merchant
+
+    @merchant.setter
+    def merchant(self, value: Optional[MerchantRiskAssessment]) -> None:
+        self.__merchant = value
+
+    @property
+    def order(self) -> Optional[OrderRiskAssessment]:
+        """
+        Type: :class:`worldline.connect.sdk.v1.domain.order_risk_assessment.OrderRiskAssessment`
+        """
+        return self.__order
+
+    @order.setter
+    def order(self, value: Optional[OrderRiskAssessment]) -> None:
+        self.__order = value
+
+    @property
+    def payment_product_id(self) -> Optional[int]:
+        """
+        | Payment product identifier
+        | Please see payment products <https://apireference.connect.worldline-solutions.com/s2sapi/v1/en_US/python/paymentproducts.html> 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
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RiskAssessment, self).to_dictionary()
+        if self.fraud_fields is not None:
+            dictionary['fraudFields'] = self.fraud_fields.to_dictionary()
+        if self.merchant is not None:
+            dictionary['merchant'] = self.merchant.to_dictionary()
+        if self.order is not None:
+            dictionary['order'] = self.order.to_dictionary()
+        if self.payment_product_id is not None:
+            dictionary['paymentProductId'] = self.payment_product_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RiskAssessment':
+        super(RiskAssessment, self).from_dictionary(dictionary)
+        if 'fraudFields' in dictionary:
+            if not isinstance(dictionary['fraudFields'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['fraudFields']))
+            value = FraudFields()
+            self.fraud_fields = value.from_dictionary(dictionary['fraudFields'])
+        if 'merchant' in dictionary:
+            if not isinstance(dictionary['merchant'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['merchant']))
+            value = MerchantRiskAssessment()
+            self.merchant = value.from_dictionary(dictionary['merchant'])
+        if 'order' in dictionary:
+            if not isinstance(dictionary['order'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['order']))
+            value = OrderRiskAssessment()
+            self.order = value.from_dictionary(dictionary['order'])
+        if 'paymentProductId' in dictionary:
+            self.payment_product_id = dictionary['paymentProductId']
+        return self

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

@@ -0,0 +1,64 @@
+# -*- 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.v1.domain.bank_account_bban import BankAccountBban
+from worldline.connect.sdk.v1.domain.bank_account_iban import BankAccountIban
+from worldline.connect.sdk.v1.domain.risk_assessment import RiskAssessment
+
+
+class RiskAssessmentBankAccount(RiskAssessment):
+
+    __bank_account_bban: Optional[BankAccountBban] = None
+    __bank_account_iban: Optional[BankAccountIban] = None
+
+    @property
+    def bank_account_bban(self) -> Optional[BankAccountBban]:
+        """
+        | Object containing account holder name and bank account information
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_bban.BankAccountBban`
+        """
+        return self.__bank_account_bban
+
+    @bank_account_bban.setter
+    def bank_account_bban(self, value: Optional[BankAccountBban]) -> None:
+        self.__bank_account_bban = value
+
+    @property
+    def bank_account_iban(self) -> Optional[BankAccountIban]:
+        """
+        | Object containing account holder name and IBAN information
+
+        Type: :class:`worldline.connect.sdk.v1.domain.bank_account_iban.BankAccountIban`
+        """
+        return self.__bank_account_iban
+
+    @bank_account_iban.setter
+    def bank_account_iban(self, value: Optional[BankAccountIban]) -> None:
+        self.__bank_account_iban = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RiskAssessmentBankAccount, self).to_dictionary()
+        if self.bank_account_bban is not None:
+            dictionary['bankAccountBban'] = self.bank_account_bban.to_dictionary()
+        if self.bank_account_iban is not None:
+            dictionary['bankAccountIban'] = self.bank_account_iban.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RiskAssessmentBankAccount':
+        super(RiskAssessmentBankAccount, self).from_dictionary(dictionary)
+        if 'bankAccountBban' in dictionary:
+            if not isinstance(dictionary['bankAccountBban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountBban']))
+            value = BankAccountBban()
+            self.bank_account_bban = value.from_dictionary(dictionary['bankAccountBban'])
+        if 'bankAccountIban' in dictionary:
+            if not isinstance(dictionary['bankAccountIban'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['bankAccountIban']))
+            value = BankAccountIban()
+            self.bank_account_iban = value.from_dictionary(dictionary['bankAccountIban'])
+        return self

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

@@ -0,0 +1,42 @@
+# -*- 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.v1.domain.card import Card
+from worldline.connect.sdk.v1.domain.risk_assessment import RiskAssessment
+
+
+class RiskAssessmentCard(RiskAssessment):
+
+    __card: Optional[Card] = None
+
+    @property
+    def card(self) -> Optional[Card]:
+        """
+        | Object containing Card object
+
+        Type: :class:`worldline.connect.sdk.v1.domain.card.Card`
+        """
+        return self.__card
+
+    @card.setter
+    def card(self, value: Optional[Card]) -> None:
+        self.__card = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RiskAssessmentCard, self).to_dictionary()
+        if self.card is not None:
+            dictionary['card'] = self.card.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RiskAssessmentCard':
+        super(RiskAssessmentCard, self).from_dictionary(dictionary)
+        if 'card' in dictionary:
+            if not isinstance(dictionary['card'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['card']))
+            value = Card()
+            self.card = value.from_dictionary(dictionary['card'])
+        return self

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

@@ -0,0 +1,47 @@
+# -*- 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.result_do_risk_assessment import ResultDoRiskAssessment
+
+
+class RiskAssessmentResponse(DataObject):
+
+    __results: Optional[List[ResultDoRiskAssessment]] = None
+
+    @property
+    def results(self) -> Optional[List[ResultDoRiskAssessment]]:
+        """
+        | Object that contains the results of the performed fraudchecks
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.result_do_risk_assessment.ResultDoRiskAssessment`]
+        """
+        return self.__results
+
+    @results.setter
+    def results(self, value: Optional[List[ResultDoRiskAssessment]]) -> None:
+        self.__results = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(RiskAssessmentResponse, self).to_dictionary()
+        if self.results is not None:
+            dictionary['results'] = []
+            for element in self.results:
+                if element is not None:
+                    dictionary['results'].append(element.to_dictionary())
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'RiskAssessmentResponse':
+        super(RiskAssessmentResponse, self).from_dictionary(dictionary)
+        if 'results' in dictionary:
+            if not isinstance(dictionary['results'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['results']))
+            self.results = []
+            for element in dictionary['results']:
+                value = ResultDoRiskAssessment()
+                self.results.append(value.from_dictionary(element))
+        return self

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

@@ -0,0 +1,110 @@
+# -*- 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 SchemeTokenData(DataObject):
+
+    __cardholder_name: Optional[str] = None
+    __cryptogram: Optional[str] = None
+    __eci: Optional[str] = None
+    __network_token: Optional[str] = None
+    __token_expiry_date: Optional[str] = None
+
+    @property
+    def cardholder_name(self) -> Optional[str]:
+        """
+        | The cardholder's name on the card
+
+        Type: str
+        """
+        return self.__cardholder_name
+
+    @cardholder_name.setter
+    def cardholder_name(self, value: Optional[str]) -> None:
+        self.__cardholder_name = value
+
+    @property
+    def cryptogram(self) -> Optional[str]:
+        """
+        | The Token Cryptogram is a dynamic one-time use value that is used to verify the authenticity of the transaction and the integrity of the data used in the generation of the Token Cryptogram. Visa calls this the Token Authentication Verification Value (TAVV) cryptogram.
+
+        Type: str
+        """
+        return self.__cryptogram
+
+    @cryptogram.setter
+    def cryptogram(self, value: Optional[str]) -> None:
+        self.__cryptogram = value
+
+    @property
+    def eci(self) -> Optional[str]:
+        """
+        | The Electronic Commerce Indicator you got with the Token Cryptogram
+
+        Type: str
+        """
+        return self.__eci
+
+    @eci.setter
+    def eci(self, value: Optional[str]) -> None:
+        self.__eci = value
+
+    @property
+    def network_token(self) -> Optional[str]:
+        """
+        | The network token. Note: This is called Payment Token in the EMVCo documentation
+
+        Type: str
+        """
+        return self.__network_token
+
+    @network_token.setter
+    def network_token(self, value: Optional[str]) -> None:
+        self.__network_token = value
+
+    @property
+    def token_expiry_date(self) -> Optional[str]:
+        """
+        | The expiry date of the network token
+
+        Type: str
+        """
+        return self.__token_expiry_date
+
+    @token_expiry_date.setter
+    def token_expiry_date(self, value: Optional[str]) -> None:
+        self.__token_expiry_date = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SchemeTokenData, self).to_dictionary()
+        if self.cardholder_name is not None:
+            dictionary['cardholderName'] = self.cardholder_name
+        if self.cryptogram is not None:
+            dictionary['cryptogram'] = self.cryptogram
+        if self.eci is not None:
+            dictionary['eci'] = self.eci
+        if self.network_token is not None:
+            dictionary['networkToken'] = self.network_token
+        if self.token_expiry_date is not None:
+            dictionary['tokenExpiryDate'] = self.token_expiry_date
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SchemeTokenData':
+        super(SchemeTokenData, self).from_dictionary(dictionary)
+        if 'cardholderName' in dictionary:
+            self.cardholder_name = dictionary['cardholderName']
+        if 'cryptogram' in dictionary:
+            self.cryptogram = dictionary['cryptogram']
+        if 'eci' in dictionary:
+            self.eci = dictionary['eci']
+        if 'networkToken' in dictionary:
+            self.network_token = dictionary['networkToken']
+        if 'tokenExpiryDate' in dictionary:
+            self.token_expiry_date = dictionary['tokenExpiryDate']
+        return self