connect-sdk-python2 4.0.0__zip → 4.1.0__zip

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/order_references.py

@@ -0,0 +1,166 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.order_invoice_data import OrderInvoiceData
+
+
+class OrderReferences(DataObject):
+
+    __descriptor = None
+    __invoice_data = None
+    __merchant_order_id = None
+    __merchant_reference = None
+    __provider_id = None
+    __provider_merchant_id = None
+
+    @property
+    def descriptor(self):
+        """
+        | Descriptive text that is used towards to customer, either during an online checkout at a third party and/or on the statement of the customer. For card transactions this is usually referred to as a Soft Descriptor. The maximum allowed length varies per card acquirer:
+        
+        * AIB - 22 characters
+        * American Express - 25 characters
+        * Atos Origin BNP - 15 characters
+        * Barclays - 25 characters
+        * Catella - 22 characters
+        * CBA - 20 characters
+        * Elavon - 25 characters
+        * First Data - 25 characters
+        * INICIS (INIPAY) - 22-30 characters
+        * JCB - 25 characters
+        * Merchant Solutions - 22-25 characters
+        * Payvision (EU & HK) - 25 characters
+        * SEB Euroline - 22 characters
+        * Sub1 Argentina - 15 characters
+        * Wells Fargo - 25 characters
+        
+        | Note that we advise you to use 22 characters as the max length as beyond this our experience is that issuers will start to truncate. We currently also only allow per API call overrides for AIB and Barclays
+        | For alternative payment products the maximum allowed length varies per payment product:
+        
+        * 402 e-Przelewy - 30 characters
+        * 404 INICIS - 80 characters
+        * 802 Nordea ePayment Finland - 234 characters
+        * 809 iDeal - 32 characters
+        * 836 SOFORT - 42 characters
+        * 840 PayPal - 127 characters
+        * 841 WebMoney - 175 characters
+        * 849 Yandex - 64 characters
+        * 861 Alipay - 256 characters
+        * 863 WeChat Pay - 32 characters
+        * 880 BOKU - 20 characters
+        * 8580 Qiwi - 255 characters
+        * 1504 Konbini - 80 characters
+        
+        | All other payment products don't support a descriptor.
+
+        Type: str
+        """
+        return self.__descriptor
+
+    @descriptor.setter
+    def descriptor(self, value):
+        self.__descriptor = value
+
+    @property
+    def invoice_data(self):
+        """
+        | Object containing additional invoice data
+
+        Type: :class:`worldline.connect.sdk.v1.domain.order_invoice_data.OrderInvoiceData`
+        """
+        return self.__invoice_data
+
+    @invoice_data.setter
+    def invoice_data(self, value):
+        self.__invoice_data = value
+
+    @property
+    def merchant_order_id(self):
+        """
+        | Your order identifier
+        | Note: This does not need to have a unique value for each transaction. This allows your to link multiple transactions to the same logical order in your system.
+
+        Type: long
+        """
+        return self.__merchant_order_id
+
+    @merchant_order_id.setter
+    def merchant_order_id(self, value):
+        self.__merchant_order_id = value
+
+    @property
+    def merchant_reference(self):
+        """
+        | Note that the maximum length of this field for transactions processed on the GlobalCollect platform is 30. Note that the maximum length of this field for transactions processed on the WL Online Payment Acceptance Platform platform is 50. Your unique reference of the transaction that is also returned in our report files. This is almost always used for your reconciliation of our report files.
+
+        Type: str
+        """
+        return self.__merchant_reference
+
+    @merchant_reference.setter
+    def merchant_reference(self, value):
+        self.__merchant_reference = value
+
+    @property
+    def provider_id(self):
+        """
+        | Provides an additional means of reconciliation for Gateway merchants
+
+        Type: str
+        """
+        return self.__provider_id
+
+    @provider_id.setter
+    def provider_id(self, value):
+        self.__provider_id = value
+
+    @property
+    def provider_merchant_id(self):
+        """
+        | Provides an additional means of reconciliation, this is the MerchantId used at the provider
+
+        Type: str
+        """
+        return self.__provider_merchant_id
+
+    @provider_merchant_id.setter
+    def provider_merchant_id(self, value):
+        self.__provider_merchant_id = value
+
+    def to_dictionary(self):
+        dictionary = super(OrderReferences, self).to_dictionary()
+        if self.descriptor is not None:
+            dictionary['descriptor'] = self.descriptor
+        if self.invoice_data is not None:
+            dictionary['invoiceData'] = self.invoice_data.to_dictionary()
+        if self.merchant_order_id is not None:
+            dictionary['merchantOrderId'] = self.merchant_order_id
+        if self.merchant_reference is not None:
+            dictionary['merchantReference'] = self.merchant_reference
+        if self.provider_id is not None:
+            dictionary['providerId'] = self.provider_id
+        if self.provider_merchant_id is not None:
+            dictionary['providerMerchantId'] = self.provider_merchant_id
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(OrderReferences, self).from_dictionary(dictionary)
+        if 'descriptor' in dictionary:
+            self.descriptor = dictionary['descriptor']
+        if 'invoiceData' in dictionary:
+            if not isinstance(dictionary['invoiceData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['invoiceData']))
+            value = OrderInvoiceData()
+            self.invoice_data = value.from_dictionary(dictionary['invoiceData'])
+        if 'merchantOrderId' in dictionary:
+            self.merchant_order_id = dictionary['merchantOrderId']
+        if 'merchantReference' in dictionary:
+            self.merchant_reference = dictionary['merchantReference']
+        if 'providerId' in dictionary:
+            self.provider_id = dictionary['providerId']
+        if 'providerMerchantId' in dictionary:
+            self.provider_merchant_id = dictionary['providerMerchantId']
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/order_references_approve_payment.py

@@ -0,0 +1,36 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class OrderReferencesApprovePayment(DataObject):
+
+    __merchant_reference = None
+
+    @property
+    def merchant_reference(self):
+        """
+        | Your (unique) reference for the transaction that you can use to reconcile our report files
+
+        Type: str
+        """
+        return self.__merchant_reference
+
+    @merchant_reference.setter
+    def merchant_reference(self, value):
+        self.__merchant_reference = value
+
+    def to_dictionary(self):
+        dictionary = super(OrderReferencesApprovePayment, self).to_dictionary()
+        if self.merchant_reference is not None:
+            dictionary['merchantReference'] = self.merchant_reference
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(OrderReferencesApprovePayment, self).from_dictionary(dictionary)
+        if 'merchantReference' in dictionary:
+            self.merchant_reference = dictionary['merchantReference']
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/order_risk_assessment.py

@@ -0,0 +1,106 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.additional_order_input_airline_data import AdditionalOrderInputAirlineData
+from worldline.connect.sdk.v1.domain.amount_of_money import AmountOfMoney
+from worldline.connect.sdk.v1.domain.customer_risk_assessment import CustomerRiskAssessment
+from worldline.connect.sdk.v1.domain.shipping_risk_assessment import ShippingRiskAssessment
+
+
+class OrderRiskAssessment(DataObject):
+
+    __additional_input = None
+    __amount_of_money = None
+    __customer = None
+    __shipping = None
+
+    @property
+    def additional_input(self):
+        """
+        | Object containing additional input on the order
+
+        Type: :class:`worldline.connect.sdk.v1.domain.additional_order_input_airline_data.AdditionalOrderInputAirlineData`
+        """
+        return self.__additional_input
+
+    @additional_input.setter
+    def additional_input(self, value):
+        self.__additional_input = value
+
+    @property
+    def amount_of_money(self):
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`worldline.connect.sdk.v1.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__amount_of_money
+
+    @amount_of_money.setter
+    def amount_of_money(self, value):
+        self.__amount_of_money = value
+
+    @property
+    def customer(self):
+        """
+        | Object containing the details of the customer
+
+        Type: :class:`worldline.connect.sdk.v1.domain.customer_risk_assessment.CustomerRiskAssessment`
+        """
+        return self.__customer
+
+    @customer.setter
+    def customer(self, value):
+        self.__customer = value
+
+    @property
+    def shipping(self):
+        """
+        | Object containing information regarding shipping / delivery
+
+        Type: :class:`worldline.connect.sdk.v1.domain.shipping_risk_assessment.ShippingRiskAssessment`
+        """
+        return self.__shipping
+
+    @shipping.setter
+    def shipping(self, value):
+        self.__shipping = value
+
+    def to_dictionary(self):
+        dictionary = super(OrderRiskAssessment, self).to_dictionary()
+        if self.additional_input is not None:
+            dictionary['additionalInput'] = self.additional_input.to_dictionary()
+        if self.amount_of_money is not None:
+            dictionary['amountOfMoney'] = self.amount_of_money.to_dictionary()
+        if self.customer is not None:
+            dictionary['customer'] = self.customer.to_dictionary()
+        if self.shipping is not None:
+            dictionary['shipping'] = self.shipping.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(OrderRiskAssessment, self).from_dictionary(dictionary)
+        if 'additionalInput' in dictionary:
+            if not isinstance(dictionary['additionalInput'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['additionalInput']))
+            value = AdditionalOrderInputAirlineData()
+            self.additional_input = value.from_dictionary(dictionary['additionalInput'])
+        if 'amountOfMoney' in dictionary:
+            if not isinstance(dictionary['amountOfMoney'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amountOfMoney']))
+            value = AmountOfMoney()
+            self.amount_of_money = value.from_dictionary(dictionary['amountOfMoney'])
+        if 'customer' in dictionary:
+            if not isinstance(dictionary['customer'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['customer']))
+            value = CustomerRiskAssessment()
+            self.customer = value.from_dictionary(dictionary['customer'])
+        if 'shipping' in dictionary:
+            if not isinstance(dictionary['shipping'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['shipping']))
+            value = ShippingRiskAssessment()
+            self.shipping = value.from_dictionary(dictionary['shipping'])
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/order_status_output.py

@@ -0,0 +1,232 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+from worldline.connect.sdk.v1.domain.api_error import APIError
+from worldline.connect.sdk.v1.domain.key_value_pair import KeyValuePair
+
+
+class OrderStatusOutput(DataObject):
+
+    __errors = None
+    __is_cancellable = None
+    __is_retriable = None
+    __provider_raw_output = None
+    __status_category = None
+    __status_code = None
+    __status_code_change_date_time = None
+
+    @property
+    def errors(self):
+        """
+        | Custom object contains the set of errors
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.api_error.APIError`]
+        """
+        return self.__errors
+
+    @errors.setter
+    def errors(self, value):
+        self.__errors = value
+
+    @property
+    def is_cancellable(self):
+        """
+        | Flag indicating if the payment can be cancelled
+        
+        * true
+        * false
+
+        Type: bool
+        """
+        return self.__is_cancellable
+
+    @is_cancellable.setter
+    def is_cancellable(self, value):
+        self.__is_cancellable = value
+
+    @property
+    def is_retriable(self):
+        """
+        | Flag indicating whether a rejected payment may be retried by the merchant without incurring a fee 
+        
+        * true
+        * false
+
+        Type: bool
+        """
+        return self.__is_retriable
+
+    @is_retriable.setter
+    def is_retriable(self, value):
+        self.__is_retriable = value
+
+    @property
+    def provider_raw_output(self):
+        """
+        | This is the raw response returned by the acquirer. This property contains unprocessed data directly returned by the acquirer. It's recommended for data analysis only due to its dynamic nature, which may undergo future changes.
+
+        Type: list[:class:`worldline.connect.sdk.v1.domain.key_value_pair.KeyValuePair`]
+        """
+        return self.__provider_raw_output
+
+    @provider_raw_output.setter
+    def provider_raw_output(self, value):
+        self.__provider_raw_output = value
+
+    @property
+    def status_category(self):
+        """
+        | Highlevel status of the payment, payout or refund with the following possible values:
+        
+        * CREATED - The transaction has been created. This is the initial state once a new payment, payout or refund is created. This category groups the following statuses:
+        
+        * CREATED
+        
+        
+        * PENDING_PAYMENT: The payment is waiting on customer action. This category groups the following statuses:
+        
+        * PENDING_PAYMENT
+        * REDIRECTED
+        
+        
+        * ACCOUNT_VERIFIED: The account has been verified. This category groups the following statuses:
+        
+        * ACCOUNT_VERIFIED
+        
+        
+        * PENDING_MERCHANT: The transaction is awaiting approval to proceed with the payment, payout or refund. This category groups the following statuses:
+        
+        * PENDING_APPROVAL
+        * PENDING_COMPLETION
+        * PENDING_CAPTURE
+        * PENDING_FRAUD_APPROVAL
+        
+        
+        * PENDING_CONNECT_OR_3RD_PARTY: The transaction is in the queue to be processed. This category groups the following statuses:
+        
+        * AUTHORIZATION_REQUESTED
+        * CAPTURE_REQUESTED
+        * PAYOUT_REQUESTED
+        * REFUND_REQUESTED
+        
+        
+        * COMPLETED: The transaction has completed. This category groups the following statuses:
+        
+        * CAPTURED
+        * PAID
+        * ACCOUNT_CREDITED
+        * CHARGEBACK_NOTIFICATION
+        
+        
+        * REVERSED: The transaction has been reversed. This category groups the following statuses:
+        
+        * CHARGEBACKED
+        * REVERSED
+        
+        
+        * REFUNDED: The transaction has been refunded. This category groups the following statuses:
+        
+        * REFUNDED
+        
+        
+        * UNSUCCESSFUL: The transaction has been rejected or is in such a state that it will never become successful. This category groups the following statuses:
+        
+        * CANCELLED
+        * REJECTED
+        * REJECTED_CAPTURE
+        * REJECTED_CREDIT
+        
+        
+        
+        
+        | 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_category
+
+    @status_category.setter
+    def status_category(self, value):
+        self.__status_category = value
+
+    @property
+    def status_code(self):
+        """
+        | Numeric status code of the legacy API. It is returned to ease the migration from the legacy APIs to Worldline Connect. You should not write new business logic based on this property as it will be deprecated in a future version of the API. The value can also be found in the GlobalCollect Payment Console, in the Ogone BackOffice and in report files.
+
+        Type: int
+        """
+        return self.__status_code
+
+    @status_code.setter
+    def status_code(self, value):
+        self.__status_code = value
+
+    @property
+    def status_code_change_date_time(self):
+        """
+        | Date and time of payment
+        | Format: YYYYMMDDHH24MISS
+
+        Type: str
+        """
+        return self.__status_code_change_date_time
+
+    @status_code_change_date_time.setter
+    def status_code_change_date_time(self, value):
+        self.__status_code_change_date_time = value
+
+    def to_dictionary(self):
+        dictionary = super(OrderStatusOutput, self).to_dictionary()
+        if self.errors is not None:
+            dictionary['errors'] = []
+            for element in self.errors:
+                if element is not None:
+                    dictionary['errors'].append(element.to_dictionary())
+        if self.is_cancellable is not None:
+            dictionary['isCancellable'] = self.is_cancellable
+        if self.is_retriable is not None:
+            dictionary['isRetriable'] = self.is_retriable
+        if self.provider_raw_output is not None:
+            dictionary['providerRawOutput'] = []
+            for element in self.provider_raw_output:
+                if element is not None:
+                    dictionary['providerRawOutput'].append(element.to_dictionary())
+        if self.status_category is not None:
+            dictionary['statusCategory'] = self.status_category
+        if self.status_code is not None:
+            dictionary['statusCode'] = self.status_code
+        if self.status_code_change_date_time is not None:
+            dictionary['statusCodeChangeDateTime'] = self.status_code_change_date_time
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(OrderStatusOutput, self).from_dictionary(dictionary)
+        if 'errors' in dictionary:
+            if not isinstance(dictionary['errors'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['errors']))
+            self.errors = []
+            for element in dictionary['errors']:
+                value = APIError()
+                self.errors.append(value.from_dictionary(element))
+        if 'isCancellable' in dictionary:
+            self.is_cancellable = dictionary['isCancellable']
+        if 'isRetriable' in dictionary:
+            self.is_retriable = dictionary['isRetriable']
+        if 'providerRawOutput' in dictionary:
+            if not isinstance(dictionary['providerRawOutput'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['providerRawOutput']))
+            self.provider_raw_output = []
+            for element in dictionary['providerRawOutput']:
+                value = KeyValuePair()
+                self.provider_raw_output.append(value.from_dictionary(element))
+        if 'statusCategory' in dictionary:
+            self.status_category = dictionary['statusCategory']
+        if 'statusCode' in dictionary:
+            self.status_code = dictionary['statusCode']
+        if 'statusCodeChangeDateTime' in dictionary:
+            self.status_code_change_date_time = dictionary['statusCodeChangeDateTime']
+        return self

connect-sdk-python2-4.1.0/worldline/connect/sdk/v1/domain/order_type_information.py

@@ -0,0 +1,111 @@
+# -*- coding: utf-8 -*-
+#
+# This class was auto-generated from the API references found at
+# https://apireference.connect.worldline-solutions.com/
+#
+from worldline.connect.sdk.domain.data_object import DataObject
+
+
+class OrderTypeInformation(DataObject):
+
+    __funding_type = None
+    __purchase_type = None
+    __transaction_type = None
+    __usage_type = None
+
+    @property
+    def funding_type(self):
+        """
+        | Identifies the funding type being authenticated. Possible values are:
+        
+        * personToPerson = When it is person to person funding (P2P)
+        * agentCashOut = When fund is being paid out to final recipient in Cash by company's agent.
+        * businessToConsumer = When fund is being transferred from business to consumer (B2C)
+        * businessToBusiness = When fund is being transferred from business to business (B2B)
+        * prefundingStagedWallet = When funding is being used to load the funds into the wallet account.
+        * storedValueDigitalWallet = When funding is being used to load the funds into a stored value digital wallet.
+        * fundingGiftCardForPersonalUse = When funding a gift card for personal use.
+        * fundingGiftCardForSomeoneElse = When funding a gift card for someone else.
+
+        Type: str
+        """
+        return self.__funding_type
+
+    @funding_type.setter
+    def funding_type(self, value):
+        self.__funding_type = value
+
+    @property
+    def purchase_type(self):
+        """
+        | Possible values are:
+        
+        * physical
+        * digital
+
+        Type: str
+        """
+        return self.__purchase_type
+
+    @purchase_type.setter
+    def purchase_type(self, value):
+        self.__purchase_type = value
+
+    @property
+    def transaction_type(self):
+        """
+        | Identifies the type of transaction being authenticated.Possible values are:
+        
+        * purchase = The purpose of the transaction is to purchase goods or services (Default)
+        * check-acceptance = The purpose of the transaction is to accept a 'check'/'cheque'
+        * account-funding = The purpose of the transaction is to fund an account
+        * quasi-cash = The purpose of the transaction is to buy a quasi cash type product that is representative of actual cash such as money orders, traveler's checks, foreign currency, lottery tickets or casino gaming chips
+        * prepaid-activation-or-load = The purpose of the transaction is to activate or load a prepaid card
+
+        Type: str
+        """
+        return self.__transaction_type
+
+    @transaction_type.setter
+    def transaction_type(self, value):
+        self.__transaction_type = value
+
+    @property
+    def usage_type(self):
+        """
+        | Possible values are:
+        
+        * private
+        * commercial
+
+        Type: str
+        """
+        return self.__usage_type
+
+    @usage_type.setter
+    def usage_type(self, value):
+        self.__usage_type = value
+
+    def to_dictionary(self):
+        dictionary = super(OrderTypeInformation, self).to_dictionary()
+        if self.funding_type is not None:
+            dictionary['fundingType'] = self.funding_type
+        if self.purchase_type is not None:
+            dictionary['purchaseType'] = self.purchase_type
+        if self.transaction_type is not None:
+            dictionary['transactionType'] = self.transaction_type
+        if self.usage_type is not None:
+            dictionary['usageType'] = self.usage_type
+        return dictionary
+
+    def from_dictionary(self, dictionary):
+        super(OrderTypeInformation, self).from_dictionary(dictionary)
+        if 'fundingType' in dictionary:
+            self.funding_type = dictionary['fundingType']
+        if 'purchaseType' in dictionary:
+            self.purchase_type = dictionary['purchaseType']
+        if 'transactionType' in dictionary:
+            self.transaction_type = dictionary['transactionType']
+        if 'usageType' in dictionary:
+            self.usage_type = dictionary['usageType']
+        return self