def test__FacilityQuery__has_any_gsrn__no_ids_exists__returns_nothing( seeded_session, gsrn): query = FacilityQuery(seeded_session) \ .has_any_gsrn(gsrn) assert query.count() == 0
def test__FacilityQuery__has_any_public_id__no_ids_exists__returns_nothing( seeded_session, public_ids): query = FacilityQuery(seeded_session) \ .has_any_public_id(public_ids) assert query.count() == 0
def test__FacilityQuery__is_consumer__returns_correct_facilities(seeded_session): query = FacilityQuery(seeded_session) \ .is_consumer() assert query.count() > 0 assert all(f.facility_type == FacilityType.CONSUMPTION for f in query.all())
def test__FacilityQuery__is_retire_receiver__returns_correct_facilities(seeded_session): query = FacilityQuery(seeded_session) \ .is_retire_receiver() assert query.count() > 0 assert all(f.retiring_priority is not None for f in query.all())
def test__FacilityQuery__has_any_gsrn__some_ids_exists__returns_correct_facility( seeded_session, gsrn): query = FacilityQuery(seeded_session) \ .has_any_gsrn(gsrn) assert query.count() > 0 assert all(f.gsrn in gsrn for f in query.all())
def test__FacilityQuery__is_type__returns_correct_facilities( seeded_session, facility_type): query = FacilityQuery(seeded_session) \ .is_type(facility_type) assert query.count() > 0 assert all(f.facility_type == facility_type for f in query.all())
def test__FacilityQuery__has_gsrn__Facility_exists__returns_correct_facility( seeded_session, gsrn): query = FacilityQuery(seeded_session) \ .has_gsrn(gsrn) assert query.count() == 1 assert query.one().gsrn == gsrn
def test__FacilityQuery__has_any_public_id__some_ids_exists__returns_correct_facility( seeded_session, public_ids): query = FacilityQuery(seeded_session) \ .has_any_public_id(public_ids) assert query.count() > 0 assert all(f.public_id in public_ids for f in query.all())
def test__FacilityQuery__has_public_id__Facility_does_not_exist__returs_nothing( seeded_session, public_id): query = FacilityQuery(seeded_session) \ .has_public_id(public_id) assert query.count() == 0 assert query.one_or_none() is None
def test__FacilityQuery__has_public_id__Facility_exists__returns_correct_facility( seeded_session, public_id): query = FacilityQuery(seeded_session) \ .has_public_id(public_id) assert query.count() == 1 assert query.one().public_id == public_id
def test__FacilityQuery__belongs_to__Facility_exists__returns_correct_facility( seeded_session, user): query = FacilityQuery(seeded_session) \ .belongs_to(user) assert query.count() > 0 assert all(f.user_id == user.id for f in query.all())
def test__FacilityQuery__has_gsrn__Facility_does_not_exist__returs_nothing( seeded_session, gsrn): query = FacilityQuery(seeded_session) \ .has_gsrn(gsrn) assert query.count() == 0 assert query.one_or_none() is None
def test__FacilityQuery__is_eligible_to_retire__sector_does_not_exists__returns_nothing( seeded_session, ggo_sector): ggo = Mock(sector='NO-FACILITIES-HAS-THIS-SECTOR') query = FacilityQuery(seeded_session) \ .is_eligible_to_retire(ggo) assert query.count() == 0
def test__FacilityQuery__is_eligible_to_retire__sector_exists__returns_correct_facilities( seeded_session, ggo_sector): ggo = Mock(sector=ggo_sector) query = FacilityQuery(seeded_session) \ .is_eligible_to_retire(ggo) assert query.count() > 0 assert all(f.sector == ggo_sector for f in query.all()) assert all(f.facility_type == FacilityType.CONSUMPTION for f in query.all())
def get_facilities(self, user, filters, session): """ :param User user: :param FacilityFilters filters: :param Session session: :rtype: list[Facility] """ query = FacilityQuery(session) \ .belongs_to(user) if filters is not None: query = query.apply_filters(filters) return query.all()
def get_gsrn_numbers(self, user, filters, session): """ :param User user: :param FacilityFilters filters: :param Session session: :rtype: list[str] """ query = FacilityQuery(session) \ .belongs_to(user) if filters is not None: query = query.apply_filters(filters) return query.get_distinct_gsrn()
def handle_request(self, request, user, session): """ :param CreateDisclosureRequest request: :param User user: :param Session session: :rtype: CreateDisclosureResponse """ facilities = FacilityQuery(session) \ .belongs_to(user) \ .is_consumer() \ .has_any_gsrn(request.gsrn) \ .all() if not facilities: raise BadRequest('No [consuming] facilities selected') request = dh.CreateDisclosureRequest( name=request.name, description=request.description, gsrn=request.gsrn, begin=request.date_range.begin, end=request.date_range.end, max_resolution=request.max_resolution, publicize_meteringpoints=request.publicize_meteringpoints, publicize_gsrn=request.publicize_gsrn, publicize_physical_address=request.publicize_physical_address, ) response = datahub.create_disclosure(user.access_token, request) return CreateDisclosureResponse( success=True, id=response.id, )
def test__FacilityQuery__get_distinct_sectors__facilities_does_notexists__returns_empty_list(seeded_session): distinct_sectors = FacilityQuery(seeded_session) \ .has_gsrn('NO-FACILITY-HAS-THIS-GSRN') \ .get_distinct_sectors() assert sorted(distinct_sectors) == []
def save_imported_meteringpoints(user, response, session): """ :param originexample.auth.User user: :param originexample.services.datahub.GetMeteringPointsResponse response: :param sqlalchemy.orm.Session session: :rtype: list[Facility] """ imported_facilities = [] for meteringpoint in response.meteringpoints: count = FacilityQuery(session) \ .has_gsrn(meteringpoint.gsrn) \ .count() if count > 0: logger.info( f'Skipping meteringpoint with GSRN: {meteringpoint.gsrn} (already exists in DB)', extra={ 'gsrn': meteringpoint.gsrn, 'subject': user.sub, 'pipeline': 'import_meteringpoints', 'task': 'import_meteringpoints_and_insert_to_db', }) continue if meteringpoint.type is MeteringPointType.PRODUCTION: facility_type = FacilityType.PRODUCTION elif meteringpoint.type is MeteringPointType.CONSUMPTION: facility_type = FacilityType.CONSUMPTION else: raise RuntimeError('Should NOT have happened!') imported_facilities.append( Facility( user=user, gsrn=meteringpoint.gsrn, sector=meteringpoint.sector, facility_type=facility_type, technology_code=meteringpoint.technology_code, fuel_code=meteringpoint.fuel_code, street_code=meteringpoint.street_code, street_name=meteringpoint.street_name, building_number=meteringpoint.building_number, city_name=meteringpoint.city_name, postcode=meteringpoint.postcode, municipality_code=meteringpoint.municipality_code, )) logger.info(f'Imported meteringpoint with GSRN: {meteringpoint.gsrn}', extra={ 'gsrn': meteringpoint.gsrn, 'subject': user.sub, 'pipeline': 'import_meteringpoints', 'task': 'import_meteringpoints_and_insert_to_db', }) session.add_all(imported_facilities) session.flush() return imported_facilities
def get_facilities(self, user, facility_public_ids, session): """ :param User user: :param list[str] facility_public_ids: :param Session session: """ return FacilityQuery(session) \ .belongs_to(user) \ .has_any_public_id(facility_public_ids) \ .all()
def get_facilities(self, ggo): """ :param Ggo ggo: :rtype: list[Facility] """ return FacilityQuery(self.session) \ .belongs_to(self.agreement.user_to) \ .is_retire_receiver() \ .is_eligible_to_retire(ggo) \ .all()
def get_facilities(self, user, facility_gsrn, session): """ :param User user: :param list[str] facility_gsrn: :param Session session: :rtype: list[Facility] """ return FacilityQuery(session) \ .belongs_to(user) \ .has_any_gsrn(facility_gsrn) \ .all()
def facility_exists(self, gsrn, session): """ :param str gsrn: :param sqlalchemy.orm.Session session: :rtype: bool """ count = FacilityQuery(session) \ .has_gsrn(gsrn) \ .count() return count > 0
def get_retire_consumers(self, user, ggo, session): """ TODO test this :param User user: :param Ggo ggo: :param sqlalchemy.orm.Session session: :rtype: collections.abc.Iterable[RetiringConsumer] """ facilities = FacilityQuery(session) \ .belongs_to(user) \ .is_retire_receiver() \ .is_eligible_to_retire(ggo) \ .order_by(Facility.retiring_priority.asc()) \ .all() for facility in facilities: yield RetiringConsumer(facility)
def test__FacilityQuery__get_distinct_sectors__facilities_exists__returns_list_of_correct_sectors(seeded_session): distinct_sectors = FacilityQuery(seeded_session) \ .get_distinct_sectors() assert sorted(distinct_sectors) == ['DK1', 'DK2']
def test__FacilityQuery__belongs_to__Facility_does_not_exists__returns_nothing(seeded_session): query = FacilityQuery(seeded_session) \ .belongs_to(user4) assert query.count() == 0