def serialize(cls, share_detail: ShareDetail) -> Dict:
return {
cls._FIELD_PAYMENT:
converter.serialize(share_detail._payment_field_for_request),
cls._FIELD_READ_ONLY:
converter.serialize(share_detail._read_only_field_for_request),
cls._FIELD_DRAFT_PAYMENT:
converter.serialize(share_detail._draft_payment),
}
def serialize(cls, installation: Installation) -> List:
return [
{
cls._FIELD_ID: converter.serialize(installation.id_)
},
{
cls._FIELD_TOKEN: converter.serialize(installation.token)
},
{
cls._FIELD_SERVER_PUBLIC_KEY:
converter.serialize(installation.server_public_key)
},
]
def serialize(cls, share_detail):
"""
:type share_detail: object_.ShareDetail
:rtype: dict
"""
return {
cls._FIELD_PAYMENT:
converter.serialize(share_detail.payment),
cls._FIELD_READ_ONLY:
converter.serialize(share_detail.read_only),
cls._FIELD_DRAFT_PAYMENT:
converter.serialize(share_detail.draft_payment),
}
async def async_update(self, *_):
"""Update the data from bunq."""
from bunq.sdk.exception import BunqException, ApiException
from bunq.sdk.model.generated import endpoint
from bunq.sdk.json import converter
try:
# get the account list which includes the balance
acc_resp = await self.hass.async_add_executor_job(
endpoint.MonetaryAccount.list)
accounts = converter.serialize(acc_resp.value)
# create a dict with the id and the balance value
self.data = {
a['MonetaryAccountBank']['id']:
float(a['MonetaryAccountBank']['balance']['value'])
for a in accounts}
# update the individual sensors
await self.update_devices()
except KeyError:
# if the key (the account id) is not found warn
# can happen when a account is deleted in Bunq
# but still present in HA
_LOGGER.warning('Count not find account in API results.')
except (BunqException, ApiException) as err:
# if the Bunq sdk errors out there is
# something wrong with the user setup
# or the api call
# log the error and raise HA error
_LOGGER.error(err)
def serialize(cls, monetary_account_reference):
"""
:type monetary_account_reference: object_.MonetaryAccountReference
:rtype: dict
"""
return converter.serialize(monetary_account_reference.pointer)
async def async_setup_platform(hass, config, async_add_entities,
discovery_info=None):
"""Set up the Bunq Bank sensor platform."""
from bunq.sdk.context import (
ApiContext, ApiEnvironmentType,
BunqContext)
from bunq.sdk.exception import BunqException, ApiException
from bunq.sdk.model.generated import endpoint
from bunq.sdk.json import converter
# set environment type
api_environment = ApiEnvironmentType.SANDBOX \
if config.get(CONF_SANDBOX) else ApiEnvironmentType.PRODUCTION
accs = []
try:
# create the api context variable
bunq_context = ApiContext(
api_environment,
config.get(CONF_API_KEY),
'Home Assistant'
)
# ensure the key is active, or activate
bunq_context.ensure_session_active()
# load user context from api context (not IO)
# checks if the user has active accounts
# raises BunqException otherwise
BunqContext.load_api_context(bunq_context)
# call the account list endpoint
accounts = converter.serialize(
endpoint.MonetaryAccount.list().value)
# create and add the devices to the list
accs = [
BunqAccountSensor(
acc['MonetaryAccountBank']['description'],
acc['MonetaryAccountBank']['id'],
acc['MonetaryAccountBank']['currency'],
float(acc['MonetaryAccountBank']['balance']['value']))
for acc in accounts
]
async_add_entities(accs)
# create the refresh object
data = BunqData(hass, bunq_context, accs)
# schedule the first update
await data.schedule_update(INTERVAL_TO_NEXT_REFRESH)
except ApiException as err:
# if there is something wrong with the user setup
# such as a incorrect key or invalid IP address
# log the error and raise HA error
# nothing to setup further until the key is changed
_LOGGER.error(err)
except BunqException as err:
# if the Bunq sdk errors out there is
# such as API rate limit throtteling
# log the error and raise PlatformNotReady to retry
_LOGGER.error(err)
raise PlatformNotReady
def serialize(cls, installation):
"""
:type installation: core.Installation
:rtype: list
"""
return [
{
cls._FIELD_ID: converter.serialize(installation.id_)
},
{
cls._FIELD_TOKEN: converter.serialize(installation.token)
},
{
cls._FIELD_SERVER_PUBLIC_KEY:
converter.serialize(installation.server_public_key),
},
]
def test_api_scenario_payment_listing_with_pagination(self):
self._ensure_enough_payments()
payments_expected = self._payments_required()
pagination = client.Pagination()
pagination.count = self._PAYMENT_LISTING_PAGE_SIZE
response_latest = self._list_payments(pagination.url_params_count_only)
pagination_latest = response_latest.pagination
response_previous = self._list_payments(
pagination_latest.url_params_previous_page)
pagination_previous = response_previous.pagination
response_previous_next = self._list_payments(
pagination_previous.url_params_next_page)
payments_previous = response_previous.value
payments_previous_next = response_previous_next.value
payments_actual = payments_previous_next + payments_previous
payments_expected_serialized = converter.serialize(payments_expected)
payments_actual_serialized = converter.serialize(payments_actual)
self.assertEqual(payments_expected_serialized,
payments_actual_serialized)
def serialize(cls, session_server: SessionServer) -> List:
return [
{
cls._FIELD_ID: converter.serialize(session_server.id_)
},
{
cls._FIELD_TOKEN: converter.serialize(session_server.token)
},
{
cls._FIELD_USER_COMPANY:
converter.serialize(session_server.user_company),
},
{
cls._FIELD_USER_PERSON:
converter.serialize(session_server.user_person),
},
{
cls._FIELD_USER_API_KEY:
converter.serialize(session_server.user_api_key),
},
{
cls._FIELD_USER_PAYMENT_SERVER_PROVIDER:
converter.serialize(
session_server.user_payment_service_provider),
},
]
def serialize(cls, session_server):
"""
:type session_server: core.SessionServer
:rtype: list
"""
return [
{
cls._FIELD_ID: converter.serialize(session_server.id_)
},
{
cls._FIELD_TOKEN: converter.serialize(session_server.token)
},
{
cls._FIELD_USER_COMPANY:
converter.serialize(session_server.user_company),
},
{
cls._FIELD_USER_PERSON:
converter.serialize(session_server.user_person),
},
]
def serialize(
cls, monetary_account_reference: MonetaryAccountReference) -> Dict:
return converter.serialize(monetary_account_reference.pointer)