onlinepayments-sdk-python3 10.0.0__tar.gz → 10.1.0__tar.gz

{onlinepayments_sdk_python3-10.0.0/onlinepayments_sdk_python3.egg-info → onlinepayments_sdk_python3-10.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: onlinepayments-sdk-python3
-Version: 10.0.0
+Version: 10.1.0
 Summary: SDK to communicate with the Online Payments platform using the Online Payments Server API
 Home-page: https://github.com/wl-online-payments-direct/sdk-python3
 Author: Worldline Direct support team

{onlinepayments_sdk_python3-10.0.0 → onlinepayments_sdk_python3-10.1.0}/onlinepayments/sdk/communication/metadata_provider.py

@@ -23,7 +23,7 @@ class MetadataProvider(IMetadataProvider):
     """
     Provides meta info about the server.
     """
-    __sdk_version = "10.0.0"
+    __sdk_version = "10.1.0"
     __server_meta_info_header = "X-GCS-ServerMetaInfo"
     __prohibited_headers = tuple(sorted([__server_meta_info_header, "X-GCS-Idempotence-Key", "Date", "Content-Type", "Authorization"],
                                         key=str.lower))

{onlinepayments_sdk_python3-10.0.0 → onlinepayments_sdk_python3-10.1.0}/onlinepayments/sdk/domain/capture_output.py

@@ -2,6 +2,7 @@
 #
 # This file was automatically generated.
 #
+from datetime import datetime
 from typing import Optional
 
 from .amount_of_money import AmountOfMoney
@@ -24,11 +25,13 @@ class CaptureOutput(DataObject):
     __merchant_parameters: Optional[str] = None
     __mobile_payment_method_specific_output: Optional[MobilePaymentMethodSpecificOutput] = None
     __operation_references: Optional[OperationPaymentReferences] = None
+    __payment_creation_date: Optional[datetime] = None
     __payment_method: Optional[str] = None
     __redirect_payment_method_specific_output: Optional[RedirectPaymentMethodSpecificOutput] = None
     __references: Optional[PaymentReferences] = None
     __sepa_direct_debit_payment_method_specific_output: Optional[SepaDirectDebitPaymentMethodSpecificOutput] = None
     __surcharge_specific_output: Optional[SurchargeSpecificOutput] = None
+    __transaction_date: Optional[datetime] = None
 
     @property
     def acquired_amount(self) -> Optional[AmountOfMoney]:
@@ -123,6 +126,19 @@ class CaptureOutput(DataObject):
     def operation_references(self, value: Optional[OperationPaymentReferences]) -> None:
         self.__operation_references = value
 
+    @property
+    def payment_creation_date(self) -> Optional[datetime]:
+        """
+        | Date and time when the current payment was first created
+
+        Type: datetime
+        """
+        return self.__payment_creation_date
+
+    @payment_creation_date.setter
+    def payment_creation_date(self, value: Optional[datetime]) -> None:
+        self.__payment_creation_date = value
+
     @property
     def payment_method(self) -> Optional[str]:
         """
@@ -188,6 +204,19 @@ class CaptureOutput(DataObject):
     def surcharge_specific_output(self, value: Optional[SurchargeSpecificOutput]) -> None:
         self.__surcharge_specific_output = value
 
+    @property
+    def transaction_date(self) -> Optional[datetime]:
+        """
+        | It is the server-side processing date and time of the transaction.
+
+        Type: datetime
+        """
+        return self.__transaction_date
+
+    @transaction_date.setter
+    def transaction_date(self, value: Optional[datetime]) -> None:
+        self.__transaction_date = value
+
     def to_dictionary(self) -> dict:
         dictionary = super(CaptureOutput, self).to_dictionary()
         if self.acquired_amount is not None:
@@ -204,6 +233,8 @@ class CaptureOutput(DataObject):
             dictionary['mobilePaymentMethodSpecificOutput'] = self.mobile_payment_method_specific_output.to_dictionary()
         if self.operation_references is not None:
             dictionary['operationReferences'] = self.operation_references.to_dictionary()
+        if self.payment_creation_date is not None:
+            dictionary['paymentCreationDate'] = DataObject.format_datetime(self.payment_creation_date)
         if self.payment_method is not None:
             dictionary['paymentMethod'] = self.payment_method
         if self.redirect_payment_method_specific_output is not None:
@@ -214,6 +245,8 @@ class CaptureOutput(DataObject):
             dictionary['sepaDirectDebitPaymentMethodSpecificOutput'] = self.sepa_direct_debit_payment_method_specific_output.to_dictionary()
         if self.surcharge_specific_output is not None:
             dictionary['surchargeSpecificOutput'] = self.surcharge_specific_output.to_dictionary()
+        if self.transaction_date is not None:
+            dictionary['transactionDate'] = DataObject.format_datetime(self.transaction_date)
         return dictionary
 
     def from_dictionary(self, dictionary: dict) -> 'CaptureOutput':
@@ -247,6 +280,8 @@ class CaptureOutput(DataObject):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['operationReferences']))
             value = OperationPaymentReferences()
             self.operation_references = value.from_dictionary(dictionary['operationReferences'])
+        if 'paymentCreationDate' in dictionary:
+            self.payment_creation_date = DataObject.parse_datetime(dictionary['paymentCreationDate'])
         if 'paymentMethod' in dictionary:
             self.payment_method = dictionary['paymentMethod']
         if 'redirectPaymentMethodSpecificOutput' in dictionary:
@@ -269,4 +304,6 @@ class CaptureOutput(DataObject):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['surchargeSpecificOutput']))
             value = SurchargeSpecificOutput()
             self.surcharge_specific_output = value.from_dictionary(dictionary['surchargeSpecificOutput'])
+        if 'transactionDate' in dictionary:
+            self.transaction_date = DataObject.parse_datetime(dictionary['transactionDate'])
         return self

{onlinepayments_sdk_python3-10.0.0 → onlinepayments_sdk_python3-10.1.0}/onlinepayments/sdk/domain/create_hosted_fields_session_request.py

@@ -5,12 +5,14 @@
 from typing import List, Optional
 
 from .data_object import DataObject
+from .payment_product_filters_hosted_fields import PaymentProductFiltersHostedFields
 
 
 class CreateHostedFieldsSessionRequest(DataObject):
 
     __locale: Optional[str] = None
     __origin: Optional[str] = None
+    __payment_product_filters: Optional[PaymentProductFiltersHostedFields] = None
     __tokens: Optional[List[str]] = None
 
     @property
@@ -39,6 +41,19 @@ class CreateHostedFieldsSessionRequest(DataObject):
     def origin(self, value: Optional[str]) -> None:
         self.__origin = value
 
+    @property
+    def payment_product_filters(self) -> Optional[PaymentProductFiltersHostedFields]:
+        """
+        | Optional object that limits which payment products are allowed in the session.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_product_filters_hosted_fields.PaymentProductFiltersHostedFields`
+        """
+        return self.__payment_product_filters
+
+    @payment_product_filters.setter
+    def payment_product_filters(self, value: Optional[PaymentProductFiltersHostedFields]) -> None:
+        self.__payment_product_filters = value
+
     @property
     def tokens(self) -> Optional[List[str]]:
         """
@@ -58,6 +73,8 @@ class CreateHostedFieldsSessionRequest(DataObject):
             dictionary['locale'] = self.locale
         if self.origin is not None:
             dictionary['origin'] = self.origin
+        if self.payment_product_filters is not None:
+            dictionary['paymentProductFilters'] = self.payment_product_filters.to_dictionary()
         if self.tokens is not None:
             dictionary['tokens'] = []
             for element in self.tokens:
@@ -71,6 +88,11 @@ class CreateHostedFieldsSessionRequest(DataObject):
             self.locale = dictionary['locale']
         if 'origin' in dictionary:
             self.origin = dictionary['origin']
+        if 'paymentProductFilters' in dictionary:
+            if not isinstance(dictionary['paymentProductFilters'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['paymentProductFilters']))
+            value = PaymentProductFiltersHostedFields()
+            self.payment_product_filters = value.from_dictionary(dictionary['paymentProductFilters'])
         if 'tokens' in dictionary:
             if not isinstance(dictionary['tokens'], list):
                 raise TypeError('value \'{}\' is not a list'.format(dictionary['tokens']))

onlinepayments_sdk_python3-10.1.0/onlinepayments/sdk/domain/get_payment_links_by_merchant_group_request.py

@@ -0,0 +1,85 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+from .pagination import Pagination
+from .payment_link_overview_filtering import PaymentLinkOverviewFiltering
+from .payment_link_overview_sorting import PaymentLinkOverviewSorting
+
+
+class GetPaymentLinksByMerchantGroupRequest(DataObject):
+
+    __filtering: Optional[PaymentLinkOverviewFiltering] = None
+    __pagination: Optional[Pagination] = None
+    __sorting: Optional[PaymentLinkOverviewSorting] = None
+
+    @property
+    def filtering(self) -> Optional[PaymentLinkOverviewFiltering]:
+        """
+        | Object containing the filter criteria for retrieving payment links.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_link_overview_filtering.PaymentLinkOverviewFiltering`
+        """
+        return self.__filtering
+
+    @filtering.setter
+    def filtering(self, value: Optional[PaymentLinkOverviewFiltering]) -> None:
+        self.__filtering = value
+
+    @property
+    def pagination(self) -> Optional[Pagination]:
+        """
+        | Object containing pagination parameters.
+
+        Type: :class:`onlinepayments.sdk.domain.pagination.Pagination`
+        """
+        return self.__pagination
+
+    @pagination.setter
+    def pagination(self, value: Optional[Pagination]) -> None:
+        self.__pagination = value
+
+    @property
+    def sorting(self) -> Optional[PaymentLinkOverviewSorting]:
+        """
+        | Object containing sorting parameters.
+
+        Type: :class:`onlinepayments.sdk.domain.payment_link_overview_sorting.PaymentLinkOverviewSorting`
+        """
+        return self.__sorting
+
+    @sorting.setter
+    def sorting(self, value: Optional[PaymentLinkOverviewSorting]) -> None:
+        self.__sorting = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(GetPaymentLinksByMerchantGroupRequest, self).to_dictionary()
+        if self.filtering is not None:
+            dictionary['filtering'] = self.filtering.to_dictionary()
+        if self.pagination is not None:
+            dictionary['pagination'] = self.pagination.to_dictionary()
+        if self.sorting is not None:
+            dictionary['sorting'] = self.sorting.to_dictionary()
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'GetPaymentLinksByMerchantGroupRequest':
+        super(GetPaymentLinksByMerchantGroupRequest, self).from_dictionary(dictionary)
+        if 'filtering' in dictionary:
+            if not isinstance(dictionary['filtering'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['filtering']))
+            value = PaymentLinkOverviewFiltering()
+            self.filtering = value.from_dictionary(dictionary['filtering'])
+        if 'pagination' in dictionary:
+            if not isinstance(dictionary['pagination'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['pagination']))
+            value = Pagination()
+            self.pagination = value.from_dictionary(dictionary['pagination'])
+        if 'sorting' in dictionary:
+            if not isinstance(dictionary['sorting'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['sorting']))
+            value = PaymentLinkOverviewSorting()
+            self.sorting = value.from_dictionary(dictionary['sorting'])
+        return self

{onlinepayments_sdk_python3-10.0.0 → onlinepayments_sdk_python3-10.1.0}/onlinepayments/sdk/domain/import_cof_series_request.py

@@ -6,12 +6,14 @@ from typing import Optional
 
 from .card_data_without_cvv import CardDataWithoutCvv
 from .data_object import DataObject
+from .network_token_data import NetworkTokenData
 
 
 class ImportCofSeriesRequest(DataObject):
 
     __card: Optional[CardDataWithoutCvv] = None
     __currency_code: Optional[str] = None
+    __network_token_data: Optional[NetworkTokenData] = None
     __payment_product_id: Optional[int] = None
     __scheme_reference_data: Optional[str] = None
     __token_id: Optional[str] = None
@@ -43,6 +45,19 @@ class ImportCofSeriesRequest(DataObject):
     def currency_code(self, value: Optional[str]) -> None:
         self.__currency_code = value
 
+    @property
+    def network_token_data(self) -> Optional[NetworkTokenData]:
+        """
+        | Object containing Network Token details
+
+        Type: :class:`onlinepayments.sdk.domain.network_token_data.NetworkTokenData`
+        """
+        return self.__network_token_data
+
+    @network_token_data.setter
+    def network_token_data(self, value: Optional[NetworkTokenData]) -> None:
+        self.__network_token_data = value
+
     @property
     def payment_product_id(self) -> Optional[int]:
         """
@@ -101,6 +116,8 @@ class ImportCofSeriesRequest(DataObject):
             dictionary['card'] = self.card.to_dictionary()
         if self.currency_code is not None:
             dictionary['currencyCode'] = self.currency_code
+        if self.network_token_data is not None:
+            dictionary['networkTokenData'] = self.network_token_data.to_dictionary()
         if self.payment_product_id is not None:
             dictionary['paymentProductId'] = self.payment_product_id
         if self.scheme_reference_data is not None:
@@ -120,6 +137,11 @@ class ImportCofSeriesRequest(DataObject):
             self.card = value.from_dictionary(dictionary['card'])
         if 'currencyCode' in dictionary:
             self.currency_code = dictionary['currencyCode']
+        if 'networkTokenData' in dictionary:
+            if not isinstance(dictionary['networkTokenData'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['networkTokenData']))
+            value = NetworkTokenData()
+            self.network_token_data = value.from_dictionary(dictionary['networkTokenData'])
         if 'paymentProductId' in dictionary:
             self.payment_product_id = dictionary['paymentProductId']
         if 'schemeReferenceData' in dictionary:

{onlinepayments_sdk_python3-10.0.0 → onlinepayments_sdk_python3-10.1.0}/onlinepayments/sdk/domain/operation_output.py

@@ -2,6 +2,7 @@
 #
 # This file was automatically generated.
 #
+from datetime import datetime
 from typing import Optional
 
 from .amount_of_money import AmountOfMoney
@@ -20,6 +21,7 @@ class OperationOutput(DataObject):
     __references: Optional[PaymentReferences] = None
     __status: Optional[str] = None
     __status_output: Optional[PaymentStatusOutput] = None
+    __transaction_date: Optional[datetime] = None
 
     @property
     def amount_of_money(self) -> Optional[AmountOfMoney]:
@@ -112,6 +114,19 @@ class OperationOutput(DataObject):
     def status_output(self, value: Optional[PaymentStatusOutput]) -> None:
         self.__status_output = value
 
+    @property
+    def transaction_date(self) -> Optional[datetime]:
+        """
+        | It is the server-side processing date and time of the transaction.
+
+        Type: datetime
+        """
+        return self.__transaction_date
+
+    @transaction_date.setter
+    def transaction_date(self, value: Optional[datetime]) -> None:
+        self.__transaction_date = value
+
     def to_dictionary(self) -> dict:
         dictionary = super(OperationOutput, self).to_dictionary()
         if self.amount_of_money is not None:
@@ -128,6 +143,8 @@ class OperationOutput(DataObject):
             dictionary['status'] = self.status
         if self.status_output is not None:
             dictionary['statusOutput'] = self.status_output.to_dictionary()
+        if self.transaction_date is not None:
+            dictionary['transactionDate'] = DataObject.format_datetime(self.transaction_date)
         return dictionary
 
     def from_dictionary(self, dictionary: dict) -> 'OperationOutput':
@@ -158,4 +175,6 @@ class OperationOutput(DataObject):
                 raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['statusOutput']))
             value = PaymentStatusOutput()
             self.status_output = value.from_dictionary(dictionary['statusOutput'])
+        if 'transactionDate' in dictionary:
+            self.transaction_date = DataObject.parse_datetime(dictionary['transactionDate'])
         return self

onlinepayments_sdk_python3-10.1.0/onlinepayments/sdk/domain/pagination.py

@@ -0,0 +1,55 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from typing import Optional
+
+from .data_object import DataObject
+
+
+class Pagination(DataObject):
+
+    __page: Optional[int] = None
+    __page_size: Optional[int] = None
+
+    @property
+    def page(self) -> Optional[int]:
+        """
+        | The page number to retrieve (1-based). Default is 1.
+
+        Type: int
+        """
+        return self.__page
+
+    @page.setter
+    def page(self, value: Optional[int]) -> None:
+        self.__page = value
+
+    @property
+    def page_size(self) -> Optional[int]:
+        """
+        | Number of results per page. Default is 50, maximum is 1000.
+
+        Type: int
+        """
+        return self.__page_size
+
+    @page_size.setter
+    def page_size(self, value: Optional[int]) -> None:
+        self.__page_size = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(Pagination, self).to_dictionary()
+        if self.page is not None:
+            dictionary['page'] = self.page
+        if self.page_size is not None:
+            dictionary['pageSize'] = self.page_size
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'Pagination':
+        super(Pagination, self).from_dictionary(dictionary)
+        if 'page' in dictionary:
+            self.page = dictionary['page']
+        if 'pageSize' in dictionary:
+            self.page_size = dictionary['pageSize']
+        return self

onlinepayments_sdk_python3-10.1.0/onlinepayments/sdk/domain/payment_link_overview_entry.py

@@ -0,0 +1,204 @@
+# -*- coding: utf-8 -*-
+#
+# This file was automatically generated.
+#
+from datetime import datetime
+from typing import Optional
+
+from .amount_of_money import AmountOfMoney
+from .data_object import DataObject
+
+
+class PaymentLinkOverviewEntry(DataObject):
+
+    __amount: Optional[AmountOfMoney] = None
+    __created_by: Optional[str] = None
+    __creation_date: Optional[datetime] = None
+    __expiration_date: Optional[datetime] = None
+    __is_reusable_link: Optional[bool] = None
+    __merchant_id: Optional[str] = None
+    __merchant_reference: Optional[str] = None
+    __payment_link_id: Optional[str] = None
+    __redirection_url: Optional[str] = None
+    __status: Optional[str] = None
+
+    @property
+    def amount(self) -> Optional[AmountOfMoney]:
+        """
+        | Object containing amount and ISO currency code attributes
+
+        Type: :class:`onlinepayments.sdk.domain.amount_of_money.AmountOfMoney`
+        """
+        return self.__amount
+
+    @amount.setter
+    def amount(self, value: Optional[AmountOfMoney]) -> None:
+        self.__amount = value
+
+    @property
+    def created_by(self) -> Optional[str]:
+        """
+        | The identifier of the user or entity that created the payment link.
+
+        Type: str
+        """
+        return self.__created_by
+
+    @created_by.setter
+    def created_by(self, value: Optional[str]) -> None:
+        self.__created_by = value
+
+    @property
+    def creation_date(self) -> Optional[datetime]:
+        """
+        | The date and time when the payment link was created. The date contains the UTC offset.
+
+        Type: datetime
+        """
+        return self.__creation_date
+
+    @creation_date.setter
+    def creation_date(self, value: Optional[datetime]) -> None:
+        self.__creation_date = value
+
+    @property
+    def expiration_date(self) -> Optional[datetime]:
+        """
+        | The date after which the payment link will not be usable to complete the payment. The date sent cannot be more than 6 months in the future or a past date. It must also contain the UTC offset.
+
+        Type: datetime
+        """
+        return self.__expiration_date
+
+    @expiration_date.setter
+    def expiration_date(self, value: Optional[datetime]) -> None:
+        self.__expiration_date = value
+
+    @property
+    def is_reusable_link(self) -> Optional[bool]:
+        """
+        | Indicates if the payment link can be used multiple times.
+
+        Type: bool
+        """
+        return self.__is_reusable_link
+
+    @is_reusable_link.setter
+    def is_reusable_link(self, value: Optional[bool]) -> None:
+        self.__is_reusable_link = value
+
+    @property
+    def merchant_id(self) -> Optional[str]:
+        """
+        | The unique Merchant Id of the merchant associated with the payment link.
+
+        Type: str
+        """
+        return self.__merchant_id
+
+    @merchant_id.setter
+    def merchant_id(self, value: Optional[str]) -> None:
+        self.__merchant_id = value
+
+    @property
+    def merchant_reference(self) -> Optional[str]:
+        """
+        | 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. It is highly recommended to provide a single MerchantReference per unique order on your side
+
+        Type: str
+        """
+        return self.__merchant_reference
+
+    @merchant_reference.setter
+    def merchant_reference(self, value: Optional[str]) -> None:
+        self.__merchant_reference = value
+
+    @property
+    def payment_link_id(self) -> Optional[str]:
+        """
+        | The unique identifier of the payment link.
+
+        Type: str
+        """
+        return self.__payment_link_id
+
+    @payment_link_id.setter
+    def payment_link_id(self, value: Optional[str]) -> None:
+        self.__payment_link_id = value
+
+    @property
+    def redirection_url(self) -> Optional[str]:
+        """
+        | The URL that will redirect the customer to the payment page to process the payment.
+
+        Type: str
+        """
+        return self.__redirection_url
+
+    @redirection_url.setter
+    def redirection_url(self, value: Optional[str]) -> None:
+        self.__redirection_url = value
+
+    @property
+    def status(self) -> Optional[str]:
+        """
+        | The current status of a payment link in its lifecycle. A payment link transitions through these states from creation to completion or termination: * ACTIVE - The payment link is active and ready to be used by the customer to complete a payment. This is the initial status when a link is created. * PAID - The payment has been successfully completed by the customer. The link can no longer be used unless it was created as a reusable link (isReusableLink = true). * CANCELLED - The payment link has been manually cancelled by the merchant and can no longer be used. * EXPIRED - The payment link has passed its expiration date (expirationDate) and is no longer usable.
+
+        Type: str
+        """
+        return self.__status
+
+    @status.setter
+    def status(self, value: Optional[str]) -> None:
+        self.__status = value
+
+    def to_dictionary(self) -> dict:
+        dictionary = super(PaymentLinkOverviewEntry, self).to_dictionary()
+        if self.amount is not None:
+            dictionary['amount'] = self.amount.to_dictionary()
+        if self.created_by is not None:
+            dictionary['createdBy'] = self.created_by
+        if self.creation_date is not None:
+            dictionary['creationDate'] = DataObject.format_datetime(self.creation_date)
+        if self.expiration_date is not None:
+            dictionary['expirationDate'] = DataObject.format_datetime(self.expiration_date)
+        if self.is_reusable_link is not None:
+            dictionary['isReusableLink'] = self.is_reusable_link
+        if self.merchant_id is not None:
+            dictionary['merchantId'] = self.merchant_id
+        if self.merchant_reference is not None:
+            dictionary['merchantReference'] = self.merchant_reference
+        if self.payment_link_id is not None:
+            dictionary['paymentLinkId'] = self.payment_link_id
+        if self.redirection_url is not None:
+            dictionary['redirectionUrl'] = self.redirection_url
+        if self.status is not None:
+            dictionary['status'] = self.status
+        return dictionary
+
+    def from_dictionary(self, dictionary: dict) -> 'PaymentLinkOverviewEntry':
+        super(PaymentLinkOverviewEntry, self).from_dictionary(dictionary)
+        if 'amount' in dictionary:
+            if not isinstance(dictionary['amount'], dict):
+                raise TypeError('value \'{}\' is not a dictionary'.format(dictionary['amount']))
+            value = AmountOfMoney()
+            self.amount = value.from_dictionary(dictionary['amount'])
+        if 'createdBy' in dictionary:
+            self.created_by = dictionary['createdBy']
+        if 'creationDate' in dictionary:
+            self.creation_date = DataObject.parse_datetime(dictionary['creationDate'])
+        if 'expirationDate' in dictionary:
+            self.expiration_date = DataObject.parse_datetime(dictionary['expirationDate'])
+        if 'isReusableLink' in dictionary:
+            self.is_reusable_link = dictionary['isReusableLink']
+        if 'merchantId' in dictionary:
+            self.merchant_id = dictionary['merchantId']
+        if 'merchantReference' in dictionary:
+            self.merchant_reference = dictionary['merchantReference']
+        if 'paymentLinkId' in dictionary:
+            self.payment_link_id = dictionary['paymentLinkId']
+        if 'redirectionUrl' in dictionary:
+            self.redirection_url = dictionary['redirectionUrl']
+        if 'status' in dictionary:
+            self.status = dictionary['status']
+        return self