connect-sdk-python3 4.0.0__zip → 4.0.1__zip

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

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

@@ -0,0 +1,150 @@
+# -*- 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.device_render_options import DeviceRenderOptions
+
+
+class SdkDataInput(DataObject):
+
+    __device_render_options: Optional[DeviceRenderOptions] = None
+    __sdk_app_id: Optional[str] = None
+    __sdk_encrypted_data: Optional[str] = None
+    __sdk_ephemeral_public_key: Optional[str] = None
+    __sdk_max_timeout: Optional[str] = None
+    __sdk_reference_number: Optional[str] = None
+    __sdk_transaction_id: Optional[str] = None
+
+    @property
+    def device_render_options(self) -> Optional[DeviceRenderOptions]:
+        """
+        | Object containing rendering options of the device.
+
+        Type: :class:`worldline.connect.sdk.v1.domain.device_render_options.DeviceRenderOptions`
+        """
+        return self.__device_render_options
+
+    @device_render_options.setter
+    def device_render_options(self, value: Optional[DeviceRenderOptions]) -> None:
+        self.__device_render_options = value
+
+    @property
+    def sdk_app_id(self) -> Optional[str]:
+        """
+        | Universally unique ID created upon all installations and updates of your app on a c Device. This will be newly generated and stored by the 3DS SDK for each installation or update
+
+        Type: str
+        """
+        return self.__sdk_app_id
+
+    @sdk_app_id.setter
+    def sdk_app_id(self, value: Optional[str]) -> None:
+        self.__sdk_app_id = value
+
+    @property
+    def sdk_encrypted_data(self) -> Optional[str]:
+        """
+        | JWE Object containing data encrypted by the 3-D Secure SDK
+
+        Type: str
+        """
+        return self.__sdk_encrypted_data
+
+    @sdk_encrypted_data.setter
+    def sdk_encrypted_data(self, value: Optional[str]) -> None:
+        self.__sdk_encrypted_data = value
+
+    @property
+    def sdk_ephemeral_public_key(self) -> Optional[str]:
+        """
+        | Public key component of the ephemeral key pair generated by the 3-D Secure SDK and used to establish session keys between the 3-D Secure SDK and ACS.
+
+        Type: str
+        """
+        return self.__sdk_ephemeral_public_key
+
+    @sdk_ephemeral_public_key.setter
+    def sdk_ephemeral_public_key(self, value: Optional[str]) -> None:
+        self.__sdk_ephemeral_public_key = value
+
+    @property
+    def sdk_max_timeout(self) -> Optional[str]:
+        """
+        | Indicates maximum amount of time (in minutes) for all exchanges. Minimum amount of minutes is 5.
+
+        Type: str
+        """
+        return self.__sdk_max_timeout
+
+    @sdk_max_timeout.setter
+    def sdk_max_timeout(self, value: Optional[str]) -> None:
+        self.__sdk_max_timeout = value
+
+    @property
+    def sdk_reference_number(self) -> Optional[str]:
+        """
+        | Identifies the vendor and version for the 3-D Secure SDK that is integrated in your app, assigned by EMVCo when the 3-D Secure SDK is approved.
+
+        Type: str
+        """
+        return self.__sdk_reference_number
+
+    @sdk_reference_number.setter
+    def sdk_reference_number(self, value: Optional[str]) -> None:
+        self.__sdk_reference_number = value
+
+    @property
+    def sdk_transaction_id(self) -> Optional[str]:
+        """
+        | Universally unique transaction identifier assigned by the 3-D Secure SDK to identify a single transaction.
+
+        Type: str
+        """
+        return self.__sdk_transaction_id
+
+    @sdk_transaction_id.setter
+    def sdk_transaction_id(self, value: Optional[str]) -> None:
+        self.__sdk_transaction_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SdkDataInput, self).to_dictionary()
+        if self.device_render_options is not None:
+            dictionary['deviceRenderOptions'] = self.device_render_options.to_dictionary()
+        if self.sdk_app_id is not None:
+            dictionary['sdkAppId'] = self.sdk_app_id
+        if self.sdk_encrypted_data is not None:
+            dictionary['sdkEncryptedData'] = self.sdk_encrypted_data
+        if self.sdk_ephemeral_public_key is not None:
+            dictionary['sdkEphemeralPublicKey'] = self.sdk_ephemeral_public_key
+        if self.sdk_max_timeout is not None:
+            dictionary['sdkMaxTimeout'] = self.sdk_max_timeout
+        if self.sdk_reference_number is not None:
+            dictionary['sdkReferenceNumber'] = self.sdk_reference_number
+        if self.sdk_transaction_id is not None:
+            dictionary['sdkTransactionId'] = self.sdk_transaction_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SdkDataInput':
+        super(SdkDataInput, self).from_dictionary(dictionary)
+        if 'deviceRenderOptions' in dictionary:
+            if not isinstance(dictionary['deviceRenderOptions'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['deviceRenderOptions']))
+            value = DeviceRenderOptions()
+            self.device_render_options = value.from_dictionary(dictionary['deviceRenderOptions'])
+        if 'sdkAppId' in dictionary:
+            self.sdk_app_id = dictionary['sdkAppId']
+        if 'sdkEncryptedData' in dictionary:
+            self.sdk_encrypted_data = dictionary['sdkEncryptedData']
+        if 'sdkEphemeralPublicKey' in dictionary:
+            self.sdk_ephemeral_public_key = dictionary['sdkEphemeralPublicKey']
+        if 'sdkMaxTimeout' in dictionary:
+            self.sdk_max_timeout = dictionary['sdkMaxTimeout']
+        if 'sdkReferenceNumber' in dictionary:
+            self.sdk_reference_number = dictionary['sdkReferenceNumber']
+        if 'sdkTransactionId' in dictionary:
+            self.sdk_transaction_id = dictionary['sdkTransactionId']
+        return self

connect-sdk-python3-4.0.1/worldline/connect/sdk/v1/domain/sdk_data_output.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 SdkDataOutput(DataObject):
+
+    __sdk_transaction_id: Optional[str] = None
+
+    @property
+    def sdk_transaction_id(self) -> Optional[str]:
+        """
+        | Universally unique transaction identifier assigned by the 3-D Secure SDK to identify this transaction.
+
+        Type: str
+        """
+        return self.__sdk_transaction_id
+
+    @sdk_transaction_id.setter
+    def sdk_transaction_id(self, value: Optional[str]) -> None:
+        self.__sdk_transaction_id = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(SdkDataOutput, self).to_dictionary()
+        if self.sdk_transaction_id is not None:
+            dictionary['sdkTransactionId'] = self.sdk_transaction_id
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'SdkDataOutput':
+        super(SdkDataOutput, self).from_dictionary(dictionary)
+        if 'sdkTransactionId' in dictionary:
+            self.sdk_transaction_id = dictionary['sdkTransactionId']
+        return self

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

@@ -0,0 +1,259 @@
+# -*- 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.address import Address
+
+
+class Seller(DataObject):
+
+    __address: Optional[Address] = None
+    __channel_code: Optional[str] = None
+    __description: Optional[str] = None
+    __external_reference_id: Optional[str] = None
+    __geocode: Optional[str] = None
+    __id: Optional[str] = None
+    __invoice_number: Optional[str] = None
+    __is_foreign_retailer: Optional[bool] = None
+    __mcc: Optional[str] = None
+    __name: Optional[str] = None
+    __phone_number: Optional[str] = None
+    __type: Optional[str] = None
+
+    @property
+    def address(self) -> Optional[Address]:
+        """
+        | Object containing the seller address details
+
+        Type: :class:`worldline.connect.sdk.v1.domain.address.Address`
+        """
+        return self.__address
+
+    @address.setter
+    def address(self, value: Optional[Address]) -> None:
+        self.__address = value
+
+    @property
+    def channel_code(self) -> Optional[str]:
+        """
+        | This property is specific to Visa Argentina. Channelcode according to Prisma. Please contact the acquirer to get the full list you need to use.
+
+        Type: str
+        """
+        return self.__channel_code
+
+    @channel_code.setter
+    def channel_code(self, value: Optional[str]) -> None:
+        self.__channel_code = value
+
+    @property
+    def description(self) -> Optional[str]:
+        """
+        | Description of the seller
+
+        Type: str
+        """
+        return self.__description
+
+    @description.setter
+    def description(self, value: Optional[str]) -> None:
+        self.__description = value
+
+    @property
+    def external_reference_id(self) -> Optional[str]:
+        """
+        | Seller ID assigned by the Merchant Aggregator
+
+        Type: str
+        """
+        return self.__external_reference_id
+
+    @external_reference_id.setter
+    def external_reference_id(self, value: Optional[str]) -> None:
+        self.__external_reference_id = value
+
+    @property
+    def geocode(self) -> Optional[str]:
+        """
+        | The sellers geocode
+
+        Type: str
+        """
+        return self.__geocode
+
+    @geocode.setter
+    def geocode(self, value: Optional[str]) -> None:
+        self.__geocode = value
+
+    @property
+    def id(self) -> Optional[str]:
+        """
+        | The sellers identifier
+
+        Type: str
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[str]) -> None:
+        self.__id = value
+
+    @property
+    def invoice_number(self) -> Optional[str]:
+        """
+        | Invoice number of the payment
+
+        Type: str
+        """
+        return self.__invoice_number
+
+    @invoice_number.setter
+    def invoice_number(self, value: Optional[str]) -> None:
+        self.__invoice_number = value
+
+    @property
+    def is_foreign_retailer(self) -> Optional[bool]:
+        """
+        | Indicates if the retailer is considered foreign or domestic when compared to the location of the marketplace. Possible values:
+        
+        * true - The retailer is considered foreign because they are located in a different country than the marketplace. For marketplaces located in the European Economic Area (EEA) and UK (and Gibraltar), this includes transactions where the marketplace is within the EEA and UK (and Gibraltar), but the retailer is located outside of the EEA and UK (and Gibraltar)
+        * false - The retailer is considered domestic because they are located in the same country as the marketplace. For marketplaces located in the European Economic Area (EEA) and UK (and Gibraltar), this includes transactions where the retailer is also located within the EEA and UK (and Gibraltar).
+
+        Type: bool
+        """
+        return self.__is_foreign_retailer
+
+    @is_foreign_retailer.setter
+    def is_foreign_retailer(self, value: Optional[bool]) -> None:
+        self.__is_foreign_retailer = value
+
+    @property
+    def mcc(self) -> Optional[str]:
+        """
+        | Merchant category code
+
+        Type: str
+        """
+        return self.__mcc
+
+    @mcc.setter
+    def mcc(self, value: Optional[str]) -> None:
+        self.__mcc = value
+
+    @property
+    def name(self) -> Optional[str]:
+        """
+        | Name of the seller
+
+        Type: str
+        """
+        return self.__name
+
+    @name.setter
+    def name(self, value: Optional[str]) -> None:
+        self.__name = value
+
+    @property
+    def phone_number(self) -> Optional[str]:
+        """
+        | Main Phone Number
+
+        Type: str
+        """
+        return self.__phone_number
+
+    @phone_number.setter
+    def phone_number(self, value: Optional[str]) -> None:
+        self.__phone_number = value
+
+    @property
+    def type(self) -> Optional[str]:
+        """
+        | Seller type. Possible values:
+        
+        * passport
+        * dni
+        * arg-identity-card
+        * civic-notebook
+        * enrollment-book
+        * cuil
+        * cuit
+        * general-register
+        * election-title
+        * cpf
+        * cnpj
+        * ssn
+        * citizen-ship
+        * col-identity-card
+        * alien-registration
+
+        Type: str
+        """
+        return self.__type
+
+    @type.setter
+    def type(self, value: Optional[str]) -> None:
+        self.__type = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Seller, self).to_dictionary()
+        if self.address is not None:
+            dictionary['address'] = self.address.to_dictionary()
+        if self.channel_code is not None:
+            dictionary['channelCode'] = self.channel_code
+        if self.description is not None:
+            dictionary['description'] = self.description
+        if self.external_reference_id is not None:
+            dictionary['externalReferenceId'] = self.external_reference_id
+        if self.geocode is not None:
+            dictionary['geocode'] = self.geocode
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.invoice_number is not None:
+            dictionary['invoiceNumber'] = self.invoice_number
+        if self.is_foreign_retailer is not None:
+            dictionary['isForeignRetailer'] = self.is_foreign_retailer
+        if self.mcc is not None:
+            dictionary['mcc'] = self.mcc
+        if self.name is not None:
+            dictionary['name'] = self.name
+        if self.phone_number is not None:
+            dictionary['phoneNumber'] = self.phone_number
+        if self.type is not None:
+            dictionary['type'] = self.type
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Seller':
+        super(Seller, self).from_dictionary(dictionary)
+        if 'address' in dictionary:
+            if not isinstance(dictionary['address'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['address']))
+            value = Address()
+            self.address = value.from_dictionary(dictionary['address'])
+        if 'channelCode' in dictionary:
+            self.channel_code = dictionary['channelCode']
+        if 'description' in dictionary:
+            self.description = dictionary['description']
+        if 'externalReferenceId' in dictionary:
+            self.external_reference_id = dictionary['externalReferenceId']
+        if 'geocode' in dictionary:
+            self.geocode = dictionary['geocode']
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'invoiceNumber' in dictionary:
+            self.invoice_number = dictionary['invoiceNumber']
+        if 'isForeignRetailer' in dictionary:
+            self.is_foreign_retailer = dictionary['isForeignRetailer']
+        if 'mcc' in dictionary:
+            self.mcc = dictionary['mcc']
+        if 'name' in dictionary:
+            self.name = dictionary['name']
+        if 'phoneNumber' in dictionary:
+            self.phone_number = dictionary['phoneNumber']
+        if 'type' in dictionary:
+            self.type = dictionary['type']
+        return self