def run(): ctx = context.ApiContext( context.ApiEnvironmentType.SANDBOX, '### YOUR_API_KEY ###', # Put your API key here 'test device python') ctx.save() ctx_restored = context.ApiContext.restore() print( 'Is original context equal the one saved and restored?:', converter.class_to_json(ctx) == converter.class_to_json(ctx_restored))
def create_with_list_response( cls, monetary_account_id: int = None, all_notification_filter: List[NotificationFilterUrl] = None, custom_headers: Dict[str, str] = None ) -> BunqResponse[List[NotificationFilterUrl]]: if all_notification_filter is None: all_notification_filter = [] if custom_headers is None: custom_headers = {} request_map = {cls.FIELD_NOTIFICATION_FILTERS: all_notification_filter} request_map_string = converter.class_to_json(request_map) request_map_string = cls._remove_field_for_request(request_map_string) api_client = ApiClient(cls._get_api_context()) request_bytes = request_map_string.encode() endpoint_url = cls._ENDPOINT_URL_CREATE.format( cls._determine_user_id(), cls._determine_monetary_account_id(monetary_account_id)) response_raw = api_client.post(endpoint_url, request_bytes, custom_headers) return NotificationFilterUrl._from_json_list(response_raw, cls._OBJECT_TYPE_GET)
def to_json(self) -> str: """ Serializes an ApiContext to JSON string. """ return converter.class_to_json(self)
def create_with_api_context( cls, client_payment_service_provider_certificate: str, client_payment_service_provider_certificate_chain: str, client_public_key_signature: str, api_context: ApiContext, all_custom_header=None) -> UserCredentialPasswordIp: request_map = { cls.FIELD_CLIENT_PAYMENT_SERVICE_PROVIDER_CERTIFICATE: client_payment_service_provider_certificate, cls.FIELD_CLIENT_PAYMENT_SERVICE_PROVIDER_CERTIFICATE_CHAIN: client_payment_service_provider_certificate_chain, cls.FIELD_CLIENT_PUBLIC_KEY_SIGNATURE: client_public_key_signature } if all_custom_header is None: all_custom_header = {} api_client = ApiClient(api_context) request_bytes = converter.class_to_json(request_map).encode() endpoint_url = cls._ENDPOINT_URL_CREATE response_raw = api_client.post(endpoint_url, request_bytes, all_custom_header) 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]))
def generate_request_body_bytes(cls, secret): """ :type secret: str :rtype: bytes """ return converter.class_to_json({cls.FIELD_SECRET: secret}).encode()
def to_json(self): """ Serializes an ApiContext to JSON string. :rtype: str """ return converter.class_to_json(self)
def generate_request_body_bytes(cls, public_key_string): """ :type public_key_string: str :rtype: bytes """ return converter.class_to_json({ cls.FIELD_CLIENT_PUBLIC_KEY: public_key_string, }).encode()
def test_api_context_save_json(self): """ Converts an ApiContext to JSON data, saves the ApiContext using the ApiContext.save() function with the to_JSON flag set to True, and compares whether the JSON data equals the returned JSON data from the ApiContext.save() function. """ context_json = converter.class_to_json(self._API_CONTEXT) context_saved = self._API_CONTEXT.to_json() self.assertEqual(context_saved, context_json)
def create(cls, description: str, secret: str, permitted_ips: List[str] = None, custom_headers: Dict[str, str] = None, api_context: ApiContext = None) -> BunqResponseInt: """ Create a new DeviceServer providing the installation token in the header and signing the request with the private part of the key you used to create the installation. The API Key that you are using will be bound to the IP address of the DeviceServer which you have created.<br/><br/>Using a Wildcard API Key gives you the freedom to make API calls even if the IP address has changed after the POST device-server.<br/><br/>Find out more at this link <a href="https://bunq.com/en/apikey-dynamic-ip" target="_blank">https://bunq.com/en/apikey-dynamic-ip</a>. :param description: The description of the DeviceServer. This is only for your own reference when reading the DeviceServer again. :type description: str :param secret: The API key. You can request an API key in the bunq app. :type secret: str :param permitted_ips: An array of IPs (v4 or v6) this DeviceServer will be able to do calls from. These will be linked to the API key. :type permitted_ips: list[str] :type custom_headers: dict[str, str]|None :type api_context: ApiContext :rtype: BunqResponseInt """ if api_context is None: raise BunqException(cls._ERROR_API_CONTEXT_IS_NULL) if custom_headers is None: custom_headers = {} request_map = { cls.FIELD_DESCRIPTION: description, cls.FIELD_SECRET: secret, cls.FIELD_PERMITTED_IPS: permitted_ips } api_client = ApiClient(api_context) request_bytes = converter.class_to_json(request_map).encode() endpoint_url = cls._ENDPOINT_URL_CREATE response_raw = api_client.post(endpoint_url, request_bytes, custom_headers) return BunqResponseInt.cast_from_bunq_response( cls._process_for_id(response_raw) )
def test_api_context_save(self): """ Converts an ApiContext to JSON data, saves the same ApiContext to a temporary file, and compares whether the JSON data is equal to the data in the file. Removes the temporary file before assertion. """ context_json = converter.class_to_json(self._API_CONTEXT) self._API_CONTEXT.save(self._TMP_FILE_PATH_FULL) with open(self._TMP_FILE_PATH_FULL, self._FILE_MODE_READ) as file_: context_retrieved = file_.read() os.remove(self._TMP_FILE_PATH_FULL) self.assertEqual(context_retrieved, context_json)
def test_create_oauth_client(self) -> None: if os.path.isfile(self._FILE_TEST_OAUTH_PATH_FULL): return try: client_id = OauthClient.create().value oauth_client = OauthClient.get(client_id).value self.assertIsNotNone(oauth_client) serialized_client = converter.class_to_json(oauth_client) file = open(self._FILE_TEST_OAUTH_PATH_FULL, ApiContext._FILE_MODE_WRITE) file.write(serialized_client) file.close() self.assertTrue(os.path.isfile(self._FILE_TEST_OAUTH_PATH_FULL)) except AssertionError: raise AssertionError
def to_json(self): """ :rtype: str """ return converter.class_to_json(self)
def generate_request_body_bytes(cls, secret: str) -> bytes: return converter.class_to_json({cls.FIELD_SECRET: secret}).encode()
def generate_request_body_bytes(cls, public_key_string: str) -> bytes: return converter.class_to_json({ cls.FIELD_CLIENT_PUBLIC_KEY: public_key_string, }).encode()
def to_json(self) -> str: return converter.class_to_json(self)