def setUp(self):
# Create two areas, and one areatype
# create 3 signals, 1 for area A, 1 for area B and one outside
self.area_type_district = AreaTypeFactory.create(code='district',
name='district')
min_lon, min_lat, max_lon, max_lat = BBOX
extent_lon = max_lon - min_lon
extent_lat = max_lat - min_lat
w = Polygon.from_bbox((min_lon, min_lat, min_lon + extent_lon * 0.5,
min_lat + extent_lat))
e = Polygon.from_bbox((min_lon + extent_lon * 0.5, min_lat,
min_lon + extent_lon, min_lat + extent_lat))
AreaFactory.create(name='west',
code='west',
_type=self.area_type_district,
geometry=MultiPolygon([w]))
AreaFactory.create(name='east',
code='east',
_type=self.area_type_district,
geometry=MultiPolygon([e]))
center_w = Point(
(min_lon + 0.25 * extent_lon, min_lat + 0.5 * extent_lat))
center_e = Point(
(min_lon + 0.75 * extent_lon, min_lat + 0.5 * extent_lat))
to_north = Point(
(min_lon + 0.5 * extent_lon, min_lat + 2 * extent_lat))
self.signal_west = SignalFactory.create(location__geometrie=center_w,
location__area_type_code=None,
location__area_code=None,
location__area_name=None)
self.signal_east = SignalFactory.create(location__geometrie=center_e,
location__area_type_code=None,
location__area_code=None,
location__area_name=None)
self.signal_north = SignalFactory.create(location__geometrie=to_north,
location__area_type_code=None,
location__area_code=None,
location__area_name=None)
def setUp(self):
super().setUp()
self.areas = {}
self.area_types = AreaTypeFactory.create_batch(5)
for area_type in self.area_types:
self.areas[area_type.code] = AreaFactory.create_batch(5, _type=area_type)
self.list_areas_schema = self.load_json_schema(
os.path.join(THIS_DIR, 'json_schema', 'get_signals_v1_public_areas.json')
)
def setUp(self):
super(TestPrivateAreaEndpoint, self).setUp()
self.client.force_authenticate(user=self.sia_read_write_user)
self.areas = {}
self.area_types = AreaTypeFactory.create_batch(5)
for area_type in self.area_types:
self.areas[area_type.code] = AreaFactory.create_batch(
5, _type=area_type)
self.list_areas_schema = self.load_json_schema(
os.path.join(THIS_DIR, 'json_schema',
'get_signals_v1_private_areas.json'))
def setUp(self):
geometry = MultiPolygon(
[Polygon.from_bbox([4.877157, 52.357204, 4.929686, 52.385239])],
srid=4326)
self.pt_in_center = Point(4.88, 52.36)
self.pt_out_center = Point(6, 53)
self.area = AreaFactory.create(geometry=geometry,
name='Centrum',
code='centrum',
_type__code='district')
SignalFactory.create(
location__geometrie=self.pt_in_center,
location__area_code=self.area.code,
location__area_type_code=self.area._type.code,
)
SignalFactory.create(location__geometrie=self.pt_out_center)
def setUp(self):
self.signal = SignalFactory()
self.category = CategoryFactory()
self.category_assignment = CategoryAssignment.objects.create(
category=self.category, _signal_id=self.signal.id)
self.link_category = '/signals/v1/public/terms/categories/{}/sub_categories/{}'.format(
self.category.parent.slug, self.category.slug)
geometry = MultiPolygon(
[Polygon.from_bbox([4.877157, 52.357204, 4.929686, 52.385239])],
srid=4326)
self.pt_in_center = Point(4.88, 52.36)
self.pt_out_center = Point(6, 53)
self.area = AreaFactory.create(geometry=geometry,
name='Centrum',
code='centrum',
_type__code='district')
def test_routing_with_user_no_longer_active(self):
department = DepartmentFactory.create()
user = UserFactory.create()
user.profile.departments.add(department)
geometry = geos.MultiPolygon([
geos.Polygon.from_bbox([4.877157, 52.357204, 4.929686, 52.385239])
],
srid=4326)
area = AreaFactory.create(geometry=geometry,
name='centrum',
code='centrum',
_type__name='gebied',
_type__code='stadsdeel')
expression_routing_type = ExpressionTypeFactory.create(name="routing")
expression = ExpressionFactory.create(
_type=expression_routing_type,
name="test outside",
code=f'location in areas."{area._type.name}"."{area.code}"')
routing_expression = RoutingExpressionFactory.create(
_expression=expression, _department=department, _user=user)
self.assertTrue(routing_expression.is_active)
# In the mean time the user has been deactived
user.is_active = False
user.save()
signal = SignalFactory.create(
location__geometrie=geos.Point(4.88, 52.36))
self.assertIsNone(signal.user_assignment)
# simulate applying routing rules
dsl_service = SignalDslService()
dsl_service.process_routing_rules(signal)
signal.refresh_from_db()
self.assertIsNone(signal.user_assignment)
routing_expression.refresh_from_db()
self.assertFalse(routing_expression.is_active)
def setUp(self):
geometry = geos.MultiPolygon([geos.Polygon.from_bbox([4.877157, 52.357204, 4.929686, 52.385239])], srid=4326)
self.area = AreaFactory.create(
geometry=geometry,
name='centrum',
code='centrum',
_type__name='gebied',
_type__code='stadsdeel')
self.exp_routing_type = ExpressionTypeFactory.create(name="routing")
self.department = DepartmentFactory.create()
self.location_expr = ExpressionFactory.create(
_type=self.exp_routing_type,
name="test outside",
code=f'location in areas."{self.area._type.name}"."{self.area.code}"'
)
RoutingExpressionFactory.create(
_expression=self.location_expr,
_department=self.department,
is_active=True,
order=2
)
def setUp(self):
# This setUp stands in for the cbs.py data loading script run for the
# relevant datasets. Note that REQUIRED_DATASETS must match what's in
# the CBS dataloader cbs.py.
self.area_type_code_m = REQUIRED_DATASETS[
'CBS_MUNICIPAL_BORDERS_DATASET']
self.area_type_code_w = REQUIRED_DATASETS['CBS_WIJK_DATASET']
self.area_type_code_b = REQUIRED_DATASETS['CBS_BUURT_DATASET']
self.area_type_m = AreaTypeFactory.create(code=self.area_type_code_m,
name=self.area_type_code_m)
self.area_type_w = AreaTypeFactory.create(code=self.area_type_code_w,
name=self.area_type_code_w)
self.area_type_b = AreaTypeFactory.create(code=self.area_type_code_b,
name=self.area_type_code_b)
min_lon, min_lat, max_lon, max_lat = BBOX
extent_lon = max_lon - min_lon
extent_lat = max_lat - min_lat
amsterdam_geom = MultiPolygon(
[Polygon.from_bbox((min_lon, min_lat, max_lon, max_lat))])
self.area_amsterdam = AreaFactory(name='Amsterdam',
code='GM0363',
_type=self.area_type_m,
geometry=amsterdam_geom)
# Area in fake Amsterdam:
polygon_in = Polygon.from_bbox((
min_lon + extent_lon * 0.25,
min_lat + extent_lat * 0.25,
min_lon + extent_lon * 0.75,
min_lat + extent_lat * 0.75,
))
# Area in fake Amsterdam:
polygon_out = Polygon.from_bbox((
min_lon + extent_lon * 1.25,
min_lat + extent_lat * 0.25,
min_lon + extent_lon * 1.75,
min_lat + extent_lat * 0.75,
))
# Neighborhoods (note these are not valid CBS codes!)
self.area_in_amsterdam_w = AreaFactory.create(name='Wijk in Amsterdam',
code='WK036301',
_type=self.area_type_w,
geometry=MultiPolygon(
[polygon_in]))
self.area_in_amsterdam_b = AreaFactory(
name='Buurt in Amsterdam',
code='BU03630101',
_type=self.area_type_b,
geometry=MultiPolygon(polygon_in))
self.area_outside_amsterdam_w = AreaFactory(
name='Wijk buiten Amsterdam',
code='WK01',
_type=self.area_type_w,
geometry=MultiPolygon([polygon_out]))
self.area_outside_amsterdam_b = AreaFactory(name='Buurt buiten',
code='BU01234',
_type=self.area_type_b,
geometry=MultiPolygon(
[polygon_out]))