def test__MeteringPointQuery__has_gsrn__MeteringPoint_does_not_exist__returs_nothing(
seeded_session):
query = MeteringPointQuery(seeded_session) \
.has_gsrn('a GSRN not present in the database')
assert query.count() == 0
assert query.one_or_none() is None
def test__MeteringPointQuery__is_consumption__MeteringPoints_exists__returns_correct_meteringpoints(
seeded_session):
query = MeteringPointQuery(seeded_session) \
.is_consumption()
assert query.count() > 0
assert all(m.type == MeasurementType.CONSUMPTION for m in query.all())
def test__MeteringPointQuery__has_gsrn__MeteringPoint_exists__returns_correct_MeteringPoint(
seeded_session, gsrn):
query = MeteringPointQuery(seeded_session) \
.has_gsrn(gsrn)
assert query.count() == 1
assert query.one().gsrn == gsrn
def test__MeteringPointQuery__belongs_to__MeteringPoint_exists__rreturns_correct_meteringpoints(
seeded_session, sub):
query = MeteringPointQuery(seeded_session) \
.belongs_to(sub)
assert query.count() > 0
assert all(m.sub == sub for m in query.all())
def test__MeteringPointQuery__is_type__MeteringPoints_exists__returns_correct_meteringpoints(
seeded_session, type):
query = MeteringPointQuery(seeded_session) \
.is_type(type)
assert query.count() > 0
assert all(m.type == type for m in query.all())
def import_energy_type(task, subject, gsrn, session):
"""
Imports meteringpoints for a specific subject
:param celery.Task task:
:param str subject:
:param str gsrn:
:param sqlalchemy.orm.Session session:
"""
__log_extra = {
'subject': subject,
'gsrn': gsrn,
'pipeline': 'import_meteringpoints',
'task': 'import_energy_type',
}
# Get MeteringPoint from DB
try:
meteringpoint = MeteringPointQuery(session) \
.is_active() \
.has_gsrn(gsrn) \
.is_production() \
.one()
except orm.exc.NoResultFound:
raise
except Exception as e:
logger.exception(
'Failed to load MeteringPoint from database, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
# Import energy type from EnergyTypeService
try:
technology_code, fuel_code = energtype_service.get_energy_type(gsrn)
except EnergyTypeUnavailable:
raise
except Exception as e:
logger.exception('Failed to import energy type, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
# Update energy type in DB
meteringpoint.technology_code = technology_code
meteringpoint.fuel_code = fuel_code
def invoke_webhook(task, subject, gsrn, subscription_id, session):
"""
:param celery.Task task:
:param str subject:
:param str gsrn:
:param int subscription_id:
:param sqlalchemy.orm.Session session:
"""
__log_extra = {
'subject': subject,
'gsrn': gsrn,
'subscription_id': str(subscription_id),
'pipeline': 'compose',
'task': 'invoke_webhook',
}
# Get MeteringPoint from DB
try:
meteringpoint = MeteringPointQuery(session) \
.is_active() \
.has_gsrn(gsrn) \
.one()
except orm.exc.NoResultFound:
raise
except Exception as e:
logger.exception(
'Failed to load MeteringPoint from database, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
# Get webhook subscription from database
try:
subscription = webhook_service.get_subscription(
subscription_id, session)
except orm.exc.NoResultFound:
raise
except Exception as e:
logger.exception(
'Failed to load WebhookSubscription from database, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
# Publish event to webhook
try:
webhook_service.on_meteringpoint_available(subscription, meteringpoint)
except WebhookConnectionError as e:
logger.exception(
'Failed to invoke webhook: ON_METERINGPOINT_AVAILABLE (Connection error), retrying...',
extra=__log_extra)
raise task.retry(exc=e)
except WebhookError as e:
logger.exception(
'Failed to invoke webhook: ON_METERINGPOINT_AVAILABLE, retrying...',
extra=__log_extra)
raise task.retry(exc=e)
def import_measurements_for(self, gsrn, session):
try:
meteringpoint = MeteringPointQuery(session) \
.has_gsrn(str(gsrn)) \
.one()
except NoResultFound:
raise NoResultFound(f'Could not find MeteringPoint with GSRN = {gsrn}')
start_import_measurements_pipeline_for(
subject=meteringpoint.sub,
gsrn=meteringpoint.gsrn,
)
def import_energy_type_for(self, gsrn, session):
try:
meteringpoint = MeteringPointQuery(session) \
.has_gsrn(str(gsrn)) \
.is_production() \
.one()
except NoResultFound:
raise NoResultFound(f'Could not find [production] MeteringPoint with GSRN = {gsrn}')
start_import_energy_type_pipeline(
subject=meteringpoint.sub,
gsrn=meteringpoint.gsrn,
session=session,
)
def get_meteringpoint(self, sub, gsrn, session):
"""
:param str sub:
:param str gsrn:
:param Session session:
:rtype: MeteringPoint
"""
meteringpoint = MeteringPointQuery(session) \
.is_active() \
.belongs_to(sub) \
.has_gsrn(gsrn) \
.is_consumption() \
.one_or_none()
if meteringpoint is None:
raise BadRequest(
(f'MeteringPoint with GSRN "{gsrn}" is not available, '
'or is not eligible for disclosure'))
return meteringpoint
def test__MeteringPointQuery__belongs_to__MeteringPoint_does_not_exist__returs_nothing(
seeded_session):
query = MeteringPointQuery(seeded_session) \
.belongs_to('a subject that does not exists')
assert query.count() == 0