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

onlinepayments/sdk/domain/payment_product.py

@@ -0,0 +1,296 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import List, Optional
+
+from .account_on_file import AccountOnFile
+from .data_object import DataObject
+from .payment_product302_specific_data import PaymentProduct302SpecificData
+from .payment_product320_specific_data import PaymentProduct320SpecificData
+from .payment_product_display_hints import PaymentProductDisplayHints
+from .payment_product_field import PaymentProductField
+
+
+class PaymentProduct(DataObject):
+
+    __accounts_on_file: Optional[List[AccountOnFile]] = None
+    __allows_authentication: Optional[bool] = None
+    __allows_recurring: Optional[bool] = None
+    __allows_tokenization: Optional[bool] = None
+    __display_hints: Optional[PaymentProductDisplayHints] = None
+    __display_hints_list: Optional[List[PaymentProductDisplayHints]] = None
+    __fields: Optional[List[PaymentProductField]] = None
+    __id: Optional[int] = None
+    __payment_method: Optional[str] = None
+    __payment_product302_specific_data: Optional[PaymentProduct302SpecificData] = None
+    __payment_product320_specific_data: Optional[PaymentProduct320SpecificData] = None
+    __payment_product_group: Optional[str] = None
+    __uses_redirection_to3rd_party: Optional[bool] = None
+
+    @property
+    def accounts_on_file(self) -> Optional[List[AccountOnFile]]:
+        """
+        | List of tokens for that payment product
+
+        Type: list[:class:`onlinepayments.sdk.domain.account_on_file.AccountOnFile`]
+        """
+        return self.__accounts_on_file
+
+    @accounts_on_file.setter
+    def accounts_on_file(self, value: Optional[List[AccountOnFile]]) -> None:
+        self.__accounts_on_file = value
+
+    @property
+    def allows_authentication(self) -> Optional[bool]:
+        """
+        | True when 3DS authentication is supported or required for the product
+
+        Type: bool
+        """
+        return self.__allows_authentication
+
+    @allows_authentication.setter
+    def allows_authentication(self, value: Optional[bool]) -> None:
+        self.__allows_authentication = value
+
+    @property
+    def allows_recurring(self) -> Optional[bool]:
+        """
+        | Indicates if the product supports recurring payments
+        
+        * true - This payment product supports recurring payments
+        * false - This payment product does not support recurring transactions and can only be used for one-off payments
+
+        Type: bool
+        """
+        return self.__allows_recurring
+
+    @allows_recurring.setter
+    def allows_recurring(self, value: Optional[bool]) -> None:
+        self.__allows_recurring = value
+
+    @property
+    def allows_tokenization(self) -> Optional[bool]:
+        """
+        | Indicates if the payment details can be tokenized for future re-use
+        
+        * true - Payment details from payments done with this payment product can be tokenized for future re-use
+        * false - Payment details from payments done with this payment product can not be tokenized
+
+        Type: bool
+        """
+        return self.__allows_tokenization
+
+    @allows_tokenization.setter
+    def allows_tokenization(self, value: Optional[bool]) -> None:
+        self.__allows_tokenization = value
+
+    @property
+    def display_hints(self) -> Optional[PaymentProductDisplayHints]:
+        """
+        | Object containing display hints like the order of the product when shown in a list, the name of the product and the logo
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_display_hints.PaymentProductDisplayHints`
+        """
+        return self.__display_hints
+
+    @display_hints.setter
+    def display_hints(self, value: Optional[PaymentProductDisplayHints]) -> None:
+        self.__display_hints = value
+
+    @property
+    def display_hints_list(self) -> Optional[List[PaymentProductDisplayHints]]:
+        """
+        Type: list[:class:`onlinepayments.sdk.domain.payment_product_display_hints.PaymentProductDisplayHints`]
+        """
+        return self.__display_hints_list
+
+    @display_hints_list.setter
+    def display_hints_list(self, value: Optional[List[PaymentProductDisplayHints]]) -> None:
+        self.__display_hints_list = value
+
+    @property
+    def fields(self) -> Optional[List[PaymentProductField]]:
+        """
+        | Object containing all the fields and their details that are associated with this payment product. If you are not interested in the data on the fields you should have us filter them our (using filter=fields in the query-string)
+
+        Type: list[:class:`onlinepayments.sdk.domain.payment_product_field.PaymentProductField`]
+        """
+        return self.__fields
+
+    @fields.setter
+    def fields(self, value: Optional[List[PaymentProductField]]) -> None:
+        self.__fields = value
+
+    @property
+    def id(self) -> Optional[int]:
+        """
+        | The ID of the payment product in our system
+
+        Type: int
+        """
+        return self.__id
+
+    @id.setter
+    def id(self, value: Optional[int]) -> None:
+        self.__id = value
+
+    @property
+    def payment_method(self) -> Optional[str]:
+        """
+        | Payment method identifier used by the our payment engine.
+
+        Type: str
+        """
+        return self.__payment_method
+
+    @payment_method.setter
+    def payment_method(self, value: Optional[str]) -> None:
+        self.__payment_method = value
+
+    @property
+    def payment_product302_specific_data(self) -> Optional[PaymentProduct302SpecificData]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.payment_product302_specific_data.PaymentProduct302SpecificData`
+        """
+        return self.__payment_product302_specific_data
+
+    @payment_product302_specific_data.setter
+    def payment_product302_specific_data(self, value: Optional[PaymentProduct302SpecificData]) -> None:
+        self.__payment_product302_specific_data = value
+
+    @property
+    def payment_product320_specific_data(self) -> Optional[PaymentProduct320SpecificData]:
+        """
+        Type: :class:`onlinepayments.sdk.domain.payment_product320_specific_data.PaymentProduct320SpecificData`
+        """
+        return self.__payment_product320_specific_data
+
+    @payment_product320_specific_data.setter
+    def payment_product320_specific_data(self, value: Optional[PaymentProduct320SpecificData]) -> None:
+        self.__payment_product320_specific_data = value
+
+    @property
+    def payment_product_group(self) -> Optional[str]:
+        """
+        | The payment product group that has this payment product, if there is any. Not populated otherwise. Currently only one payment product group is supported:
+        
+        * cards
+
+        Type: str
+        """
+        return self.__payment_product_group
+
+    @payment_product_group.setter
+    def payment_product_group(self, value: Optional[str]) -> None:
+        self.__payment_product_group = value
+
+    @property
+    def uses_redirection_to3rd_party(self) -> Optional[bool]:
+        """
+        | Indicates whether the payment product requires redirection to a third party to complete the payment. You can use this to filter out products that require a redirect if you do not want to support that.
+        
+        * true - Redirection is required
+        * false - No redirection is required
+
+        Type: bool
+        """
+        return self.__uses_redirection_to3rd_party
+
+    @uses_redirection_to3rd_party.setter
+    def uses_redirection_to3rd_party(self, value: Optional[bool]) -> None:
+        self.__uses_redirection_to3rd_party = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct, self).to_dictionary()
+        if self.accounts_on_file is not None:
+            dictionary['accountsOnFile'] = []
+            for element in self.accounts_on_file:
+                if element is not None:
+                    dictionary['accountsOnFile'].append(element.to_dictionary())
+        if self.allows_authentication is not None:
+            dictionary['allowsAuthentication'] = self.allows_authentication
+        if self.allows_recurring is not None:
+            dictionary['allowsRecurring'] = self.allows_recurring
+        if self.allows_tokenization is not None:
+            dictionary['allowsTokenization'] = self.allows_tokenization
+        if self.display_hints is not None:
+            dictionary['displayHints'] = self.display_hints.to_dictionary()
+        if self.display_hints_list is not None:
+            dictionary['displayHintsList'] = []
+            for element in self.display_hints_list:
+                if element is not None:
+                    dictionary['displayHintsList'].append(element.to_dictionary())
+        if self.fields is not None:
+            dictionary['fields'] = []
+            for element in self.fields:
+                if element is not None:
+                    dictionary['fields'].append(element.to_dictionary())
+        if self.id is not None:
+            dictionary['id'] = self.id
+        if self.payment_method is not None:
+            dictionary['paymentMethod'] = self.payment_method
+        if self.payment_product302_specific_data is not None:
+            dictionary['paymentProduct302SpecificData'] = self.payment_product302_specific_data.to_dictionary()
+        if self.payment_product320_specific_data is not None:
+            dictionary['paymentProduct320SpecificData'] = self.payment_product320_specific_data.to_dictionary()
+        if self.payment_product_group is not None:
+            dictionary['paymentProductGroup'] = self.payment_product_group
+        if self.uses_redirection_to3rd_party is not None:
+            dictionary['usesRedirectionTo3rdParty'] = self.uses_redirection_to3rd_party
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct':
+        super(PaymentProduct, self).from_dictionary(dictionary)
+        if 'accountsOnFile' in dictionary:
+            if not isinstance(dictionary['accountsOnFile'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['accountsOnFile']))
+            self.accounts_on_file = []
+            for element in dictionary['accountsOnFile']:
+                value = AccountOnFile()
+                self.accounts_on_file.append(value.from_dictionary(element))
+        if 'allowsAuthentication' in dictionary:
+            self.allows_authentication = dictionary['allowsAuthentication']
+        if 'allowsRecurring' in dictionary:
+            self.allows_recurring = dictionary['allowsRecurring']
+        if 'allowsTokenization' in dictionary:
+            self.allows_tokenization = dictionary['allowsTokenization']
+        if 'displayHints' in dictionary:
+            if not isinstance(dictionary['displayHints'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['displayHints']))
+            value = PaymentProductDisplayHints()
+            self.display_hints = value.from_dictionary(dictionary['displayHints'])
+        if 'displayHintsList' in dictionary:
+            if not isinstance(dictionary['displayHintsList'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['displayHintsList']))
+            self.display_hints_list = []
+            for element in dictionary['displayHintsList']:
+                value = PaymentProductDisplayHints()
+                self.display_hints_list.append(value.from_dictionary(element))
+        if 'fields' in dictionary:
+            if not isinstance(dictionary['fields'], list):
+                raise TypeError('value \'{}\' is not a list'.format(dictionary['fields']))
+            self.fields = []
+            for element in dictionary['fields']:
+                value = PaymentProductField()
+                self.fields.append(value.from_dictionary(element))
+        if 'id' in dictionary:
+            self.id = dictionary['id']
+        if 'paymentMethod' in dictionary:
+            self.payment_method = dictionary['paymentMethod']
+        if 'paymentProduct302SpecificData' in dictionary:
+            if not isinstance(dictionary['paymentProduct302SpecificData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct302SpecificData']))
+            value = PaymentProduct302SpecificData()
+            self.payment_product302_specific_data = value.from_dictionary(dictionary['paymentProduct302SpecificData'])
+        if 'paymentProduct320SpecificData' in dictionary:
+            if not isinstance(dictionary['paymentProduct320SpecificData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProduct320SpecificData']))
+            value = PaymentProduct320SpecificData()
+            self.payment_product320_specific_data = value.from_dictionary(dictionary['paymentProduct320SpecificData'])
+        if 'paymentProductGroup' in dictionary:
+            self.payment_product_group = dictionary['paymentProductGroup']
+        if 'usesRedirectionTo3rdParty' in dictionary:
+            self.uses_redirection_to3rd_party = dictionary['usesRedirectionTo3rdParty']
+        return self

onlinepayments/sdk/domain/payment_product130_specific_input.py

@@ -0,0 +1,41 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .payment_product130_specific_three_d_secure import PaymentProduct130SpecificThreeDSecure
+
+
+class PaymentProduct130SpecificInput(DataObject):
+
+    __three_d_secure: Optional[PaymentProduct130SpecificThreeDSecure] = None
+
+    @property
+    def three_d_secure(self) -> Optional[PaymentProduct130SpecificThreeDSecure]:
+        """
+        | Object containing specific data regarding 3-D Secure
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product130_specific_three_d_secure.PaymentProduct130SpecificThreeDSecure`
+        """
+        return self.__three_d_secure
+
+    @three_d_secure.setter
+    def three_d_secure(self, value: Optional[PaymentProduct130SpecificThreeDSecure]) -> None:
+        self.__three_d_secure = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct130SpecificInput, self).to_dictionary()
+        if self.three_d_secure is not None:
+            dictionary['threeDSecure'] = self.three_d_secure.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct130SpecificInput':
+        super(PaymentProduct130SpecificInput, self).from_dictionary(dictionary)
+        if 'threeDSecure' in dictionary:
+            if not isinstance(dictionary['threeDSecure'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['threeDSecure']))
+            value = PaymentProduct130SpecificThreeDSecure()
+            self.three_d_secure = value.from_dictionary(dictionary['threeDSecure'])
+        return self

onlinepayments/sdk/domain/payment_product130_specific_three_d_secure.py

@@ -0,0 +1,91 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProduct130SpecificThreeDSecure(DataObject):
+
+    __acquirer_exemption: Optional[bool] = None
+    __merchant_score: Optional[str] = None
+    __number_of_items: Optional[int] = None
+    __usecase: Optional[str] = None
+
+    @property
+    def acquirer_exemption(self) -> Optional[bool]:
+        """
+        | Indicates the Acquirer TRA exemption
+
+        Type: bool
+        """
+        return self.__acquirer_exemption
+
+    @acquirer_exemption.setter
+    def acquirer_exemption(self, value: Optional[bool]) -> None:
+        self.__acquirer_exemption = value
+
+    @property
+    def merchant_score(self) -> Optional[str]:
+        """
+        | Score calculated by the 3DS Requestor and provided to CB Scoring service only.
+
+        Type: str
+        """
+        return self.__merchant_score
+
+    @merchant_score.setter
+    def merchant_score(self, value: Optional[str]) -> None:
+        self.__merchant_score = value
+
+    @property
+    def number_of_items(self) -> Optional[int]:
+        """
+        | Number of purchased items or services. 99 if more than 99 items
+
+        Type: int
+        """
+        return self.__number_of_items
+
+    @number_of_items.setter
+    def number_of_items(self, value: Optional[int]) -> None:
+        self.__number_of_items = value
+
+    @property
+    def usecase(self) -> Optional[str]:
+        """
+        | Indicates the type of payment for which an authentication is requested
+
+        Type: str
+        """
+        return self.__usecase
+
+    @usecase.setter
+    def usecase(self, value: Optional[str]) -> None:
+        self.__usecase = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct130SpecificThreeDSecure, self).to_dictionary()
+        if self.acquirer_exemption is not None:
+            dictionary['acquirerExemption'] = self.acquirer_exemption
+        if self.merchant_score is not None:
+            dictionary['merchantScore'] = self.merchant_score
+        if self.number_of_items is not None:
+            dictionary['numberOfItems'] = self.number_of_items
+        if self.usecase is not None:
+            dictionary['usecase'] = self.usecase
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct130SpecificThreeDSecure':
+        super(PaymentProduct130SpecificThreeDSecure, self).from_dictionary(dictionary)
+        if 'acquirerExemption' in dictionary:
+            self.acquirer_exemption = dictionary['acquirerExemption']
+        if 'merchantScore' in dictionary:
+            self.merchant_score = dictionary['merchantScore']
+        if 'numberOfItems' in dictionary:
+            self.number_of_items = dictionary['numberOfItems']
+        if 'usecase' in dictionary:
+            self.usecase = dictionary['usecase']
+        return self

onlinepayments/sdk/domain/payment_product3012.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProduct3012(DataObject):
+
+    __qr_code: Optional[str] = None
+    __url_intent: Optional[str] = None
+
+    @property
+    def qr_code(self) -> Optional[str]:
+        """
+        | Contains a value which can be used to build a QR code (intended to be scanned by a device with the Bancontact app)
+
+        Type: str
+        """
+        return self.__qr_code
+
+    @qr_code.setter
+    def qr_code(self, value: Optional[str]) -> None:
+        self.__qr_code = value
+
+    @property
+    def url_intent(self) -> Optional[str]:
+        """
+        | Contains URL intent that can be used as the link of an "open the app" button on a device
+
+        Type: str
+        """
+        return self.__url_intent
+
+    @url_intent.setter
+    def url_intent(self, value: Optional[str]) -> None:
+        self.__url_intent = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct3012, self).to_dictionary()
+        if self.qr_code is not None:
+            dictionary['qrCode'] = self.qr_code
+        if self.url_intent is not None:
+            dictionary['urlIntent'] = self.url_intent
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct3012':
+        super(PaymentProduct3012, self).from_dictionary(dictionary)
+        if 'qrCode' in dictionary:
+            self.qr_code = dictionary['qrCode']
+        if 'urlIntent' in dictionary:
+            self.url_intent = dictionary['urlIntent']
+        return self

onlinepayments/sdk/domain/payment_product3012_specific_input.py

@@ -0,0 +1,100 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProduct3012SpecificInput(DataObject):
+
+    __force_authentication: Optional[bool] = None
+    __is_deferred_payment: Optional[bool] = None
+    __is_wip_transaction: Optional[bool] = None
+    __wip_merchant_authentication_method: Optional[str] = None
+
+    @property
+    def force_authentication(self) -> Optional[bool]:
+        """
+        | Indicate whether 3D Secure authentication should be forced.
+
+        Type: bool
+        """
+        return self.__force_authentication
+
+    @force_authentication.setter
+    def force_authentication(self, value: Optional[bool]) -> None:
+        self.__force_authentication = value
+
+    @property
+    def is_deferred_payment(self) -> Optional[bool]:
+        """
+        | Indicate whether its a deferred payment.
+
+        Type: bool
+        """
+        return self.__is_deferred_payment
+
+    @is_deferred_payment.setter
+    def is_deferred_payment(self, value: Optional[bool]) -> None:
+        self.__is_deferred_payment = value
+
+    @property
+    def is_wip_transaction(self) -> Optional[bool]:
+        """
+        | Indicate whether its wallet initiated payment.
+
+        Type: bool
+        """
+        return self.__is_wip_transaction
+
+    @is_wip_transaction.setter
+    def is_wip_transaction(self, value: Optional[bool]) -> None:
+        self.__is_wip_transaction = value
+
+    @property
+    def wip_merchant_authentication_method(self) -> Optional[str]:
+        """
+        | Indicates how the cardholder was authenticated to the Merchant Wallet in the context of the transaction to which the BEPAF is attached
+        
+        * 01 = Username/password or PIN login successfully performed by cardholder.
+        * 02 = Authentication through Secret/Private Key in Secure Hardware Solution was successfully performed.
+        * 04 = Authentication through Secret/Private Key in Secure Software Solution (for example, mobile App) was successfully performed.
+        * 08 = Location-based Authentication was successfully performed.
+        * 10 = Environmental Authentication in Secure Software Solution (mobile App) was successfully performed.
+        * 20 = Behavioral Analysis was successfully performed.
+        * 40 = Biometrics Authentication was successfully performed.
+        * 80 = Out of band user authentication was successfully performed.
+
+        Type: str
+        """
+        return self.__wip_merchant_authentication_method
+
+    @wip_merchant_authentication_method.setter
+    def wip_merchant_authentication_method(self, value: Optional[str]) -> None:
+        self.__wip_merchant_authentication_method = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct3012SpecificInput, self).to_dictionary()
+        if self.force_authentication is not None:
+            dictionary['forceAuthentication'] = self.force_authentication
+        if self.is_deferred_payment is not None:
+            dictionary['isDeferredPayment'] = self.is_deferred_payment
+        if self.is_wip_transaction is not None:
+            dictionary['isWipTransaction'] = self.is_wip_transaction
+        if self.wip_merchant_authentication_method is not None:
+            dictionary['wipMerchantAuthenticationMethod'] = self.wip_merchant_authentication_method
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct3012SpecificInput':
+        super(PaymentProduct3012SpecificInput, self).from_dictionary(dictionary)
+        if 'forceAuthentication' in dictionary:
+            self.force_authentication = dictionary['forceAuthentication']
+        if 'isDeferredPayment' in dictionary:
+            self.is_deferred_payment = dictionary['isDeferredPayment']
+        if 'isWipTransaction' in dictionary:
+            self.is_wip_transaction = dictionary['isWipTransaction']
+        if 'wipMerchantAuthenticationMethod' in dictionary:
+            self.wip_merchant_authentication_method = dictionary['wipMerchantAuthenticationMethod']
+        return self

onlinepayments/sdk/domain/payment_product3013_specific_input.py

@@ -0,0 +1,73 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class PaymentProduct3013SpecificInput(DataObject):
+
+    __market_number: Optional[str] = None
+    __purchasing_buyer_reference1: Optional[str] = None
+    __purchasing_buyer_reference2: Optional[str] = None
+
+    @property
+    def market_number(self) -> Optional[str]:
+        """
+        | An identifier that refers to the public tender
+
+        Type: str
+        """
+        return self.__market_number
+
+    @market_number.setter
+    def market_number(self, value: Optional[str]) -> None:
+        self.__market_number = value
+
+    @property
+    def purchasing_buyer_reference1(self) -> Optional[str]:
+        """
+        | An identifier allocated by the government
+
+        Type: str
+        """
+        return self.__purchasing_buyer_reference1
+
+    @purchasing_buyer_reference1.setter
+    def purchasing_buyer_reference1(self, value: Optional[str]) -> None:
+        self.__purchasing_buyer_reference1 = value
+
+    @property
+    def purchasing_buyer_reference2(self) -> Optional[str]:
+        """
+        | An identifier allocated by the government
+
+        Type: str
+        """
+        return self.__purchasing_buyer_reference2
+
+    @purchasing_buyer_reference2.setter
+    def purchasing_buyer_reference2(self, value: Optional[str]) -> None:
+        self.__purchasing_buyer_reference2 = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentProduct3013SpecificInput, self).to_dictionary()
+        if self.market_number is not None:
+            dictionary['marketNumber'] = self.market_number
+        if self.purchasing_buyer_reference1 is not None:
+            dictionary['purchasingBuyerReference1'] = self.purchasing_buyer_reference1
+        if self.purchasing_buyer_reference2 is not None:
+            dictionary['purchasingBuyerReference2'] = self.purchasing_buyer_reference2
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentProduct3013SpecificInput':
+        super(PaymentProduct3013SpecificInput, self).from_dictionary(dictionary)
+        if 'marketNumber' in dictionary:
+            self.market_number = dictionary['marketNumber']
+        if 'purchasingBuyerReference1' in dictionary:
+            self.purchasing_buyer_reference1 = dictionary['purchasingBuyerReference1']
+        if 'purchasingBuyerReference2' in dictionary:
+            self.purchasing_buyer_reference2 = dictionary['purchasingBuyerReference2']
+        return self