feature/python-sdk-psd2: ApiContext for PSD2 is now generated and stored.

Author: angelomelonas

bunq/sdk/context/api_context.py

@@ -5,7 +5,6 @@
 from typing import List, Optional
 
 from Cryptodome.PublicKey import RSA
-from Cryptodome.PublicKey.RSA import RsaKey
 
 from bunq.sdk.context.api_environment_type import ApiEnvironmentType
 from bunq.sdk.context.installation_context import InstallationContext
@@ -14,7 +13,7 @@
 from bunq.sdk.json import converter
 from bunq.sdk.model.core.payment_service_provider_credential_internal import PaymentServiceProviderCredentialInternal
 from bunq.sdk.model.generated import endpoint
-from bunq.sdk.model.generated.endpoint import UserCredentialPasswordIp
+from bunq.sdk.model.generated.endpoint import UserCredentialPasswordIp, UserPaymentServiceProvider
 from bunq.sdk.security import security
 
 if typing.TYPE_CHECKING:
@@ -63,9 +62,9 @@ def create(cls,
 
         api_context._api_key = api_key
 
-        api_context._initialize_installation()
-        api_context._register_device(description, all_permitted_ip)
-        api_context._initialize_session()
+        api_context.__initialize_installation()
+        api_context.__register_device(description, all_permitted_ip)
+        api_context.__initialize_session()
 
         return api_context
 
@@ -80,21 +79,25 @@ def create_for_psd2(cls,
                         proxy_url: List[str] = None) -> ApiContext:
         api_context = cls(environment_type, proxy_url)
 
-        api_context._initialize_installation()
+        api_context.__initialize_installation()
 
-        service_provider_credential = api_context._initialize_psd2_credential(
+        service_provider_credential = api_context.__initialize_psd2_credential(
             certificate,
             private_key,
             all_chain_certificate)
 
+        print(service_provider_credential.token_value)
+
         api_context._api_key = service_provider_credential.token_value
 
-        api_context._register_device(description, all_permitted_ip)
-        api_context._initialize_session()
+        print(api_context._api_key)
+
+        api_context.__register_device(description, all_permitted_ip)
+        api_context.__initialize_session_for_psd2(service_provider_credential)
 
         return api_context
 
-    def _initialize_installation(self) -> None:
+    def __initialize_installation(self) -> None:
         from bunq.sdk.model.core.installation import Installation
 
         private_key_client = security.generate_rsa_private_key()
@@ -114,14 +117,14 @@ def _initialize_installation(self) -> None:
             public_key_server
         )
 
-    def _initialize_psd2_credential(self,
-                                    certificate: str,
-                                    private_key: str,
-                                    all_chain_certificate: List[str], ) -> UserCredentialPasswordIp:
+    def __initialize_psd2_credential(self,
+                                     certificate: str,
+                                     private_key: str,
+                                     all_chain_certificate: List[str], ) -> UserCredentialPasswordIp:
         session_token = self.installation_context.token
         client_key_pair = self.installation_context.private_key_client
 
-        string_to_sign = security.public_key_to_string(client_key_pair.publickey()) + session_token
+        string_to_sign = security.public_key_to_string(client_key_pair.publickey()) + "\n" + session_token
         encoded_signature = security.generate_signature(string_to_sign, security.rsa_key_from_string(private_key))
 
         payment_response_provider = PaymentServiceProviderCredentialInternal.create_with_api_context(
@@ -133,19 +136,21 @@ def _initialize_psd2_credential(self,
 
         return payment_response_provider
 
-    def _register_device(self,
-                         device_description: str,
-                         permitted_ips: List[str]) -> None:
+    def __register_device(self,
+                          device_description: str,
+                          permitted_ips: List[str]) -> None:
         from bunq.sdk.model.core.device_server_internal import DeviceServerInternal
 
+        print(self.api_key)
+
         DeviceServerInternal.create(
             device_description,
             self.api_key,
             permitted_ips,
             api_context=self
         )
 
-    def _initialize_session(self) -> None:
+    def __initialize_session(self) -> None:
         from bunq.sdk.model.core.session_server import SessionServer
 
         session_server = SessionServer.create(self).value
@@ -155,6 +160,17 @@ def _initialize_session(self) -> None:
 
         self._session_context = SessionContext(token, expiry_time, user_id)
 
+    def _initialize_session_for_psd2(self, user_payment_service_provider: UserPaymentServiceProvider) -> None:
+        from bunq.sdk.model.core.session_server import SessionServer
+
+        session_server = SessionServer.create(self).value
+
+        token = session_server.token.token
+        expiry_time = self._get_expiry_timestamp(session_server)
+        user_id = session_server.get_referenced_user().id_
+
+        self._session_context = SessionContext(token, expiry_time, user_id)
+
     @classmethod
     def _get_expiry_timestamp(cls, session_server: SessionServer) -> datetime.datetime:
         timeout_seconds = cls._get_session_timeout_seconds(session_server)
@@ -168,6 +184,8 @@ def _get_session_timeout_seconds(cls, session_server: SessionServer) -> int:
             return session_server.user_company.session_timeout
         elif session_server.user_person is not None:
             return session_server.user_person.session_timeout
+        elif session_server.user_payment_service_provider is not None:
+            return session_server.user_payment_service_provider.session_timeout
         elif session_server.user_api_key is not None:
             return session_server \
                 .user_api_key \
@@ -209,7 +227,7 @@ def reset_session(self) -> None:
         """
 
         self._drop_session_context()
-        self._initialize_session()
+        self.__initialize_session()
 
     def _drop_session_context(self) -> None:
         self._session_context = None

bunq/sdk/model/core/payment_service_provider_credential_internal.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+import json
 import typing
+
 from bunq.sdk.http.api_client import ApiClient
 from bunq.sdk.json import converter
 from bunq.sdk.model.generated.endpoint import PaymentServiceProviderCredential, UserCredentialPasswordIp
@@ -10,7 +12,6 @@
 
 
 class PaymentServiceProviderCredentialInternal(PaymentServiceProviderCredential):
-
     @classmethod
     def create_with_api_context(cls,
                                 client_payment_service_provider_certificate: str,
@@ -32,4 +33,7 @@ def create_with_api_context(cls,
         endpoint_url = cls._ENDPOINT_URL_CREATE
         response_raw = api_client.post(endpoint_url, request_bytes, all_custom_header)
 
-        return UserCredentialPasswordIp.from_json(response_raw.body_bytes.decode())
+        response_body = converter.json_to_class(dict, response_raw.body_bytes.decode())
+        response_body_dict = converter.deserialize(cls, response_body[cls._FIELD_RESPONSE])[0]
+
+        return UserCredentialPasswordIp.from_json(json.dumps(response_body_dict[cls._OBJECT_TYPE_GET]))