def test_get_with_filter(self):
# Create 3 beacons
self.test_create_beacons()
# Filter by id
page = self._persistence.get_page_by_filter(
None, FilterParams.from_tuples("id", "1"), PagingParams())
assert page is not None
assert len(page.data) == 1
# Filter by udi
page = self._persistence.get_page_by_filter(
None, FilterParams.from_tuples("udi", "00002"), PagingParams())
assert page is not None
assert len(page.data) == 1
# Filter by udis
page = self._persistence.get_page_by_filter(
None, FilterParams.from_tuples("udis", '00001,00003'),
PagingParams())
assert page is not None
assert len(page.data) == 2
# Filter by udi
page = self._persistence.get_page_by_filter(
None, FilterParams.from_tuples("site_id", "1"), PagingParams())
assert page is not None
assert len(page.data) == 2
def get_count_by_filter(self, correlation_id: Optional[str], filter: FilterParams) -> int:
filter = filter or FilterParams()
key = filter.get_as_nullable_string('key')
filter_condition = {}
if key is not None:
filter_condition['key'] = key
return super().get_count_by_filter(correlation_id, filter)
def get_page_by_filter(self, correlation_id: Optional[str], filter: FilterParams, paging: PagingParams) -> DataPage:
filter = filter or FilterParams()
key = filter.get_as_nullable_string('key')
filter_condition = {}
if key is not None:
filter_condition['key'] = key
return super().get_page_by_filter(correlation_id, filter, paging, None, None)
def get_count_by_filter(self, correlation_id: Optional[str],
filter: FilterParams):
filter = filter or FilterParams()
key = filter.get_as_nullable_string('key')
filter_condition = ''
if key is not None:
filter_condition += "`key`='" + key + "'"
return super().get_count_by_filter(correlation_id, filter_condition)
def __compose_filter(self, filter_params: FilterParams):
filter_params = filter_params or FilterParams()
search = filter_params.get_as_nullable_string('search')
id = filter_params.get_as_nullable_string('id')
name = filter_params.get_as_nullable_string('name')
login = filter_params.get_as_nullable_string('login')
active = filter_params.get_as_nullable_boolean('active')
from_create_time = filter_params.get_as_nullable_datetime(
'from_create_time')
to_create_time = filter_params.get_as_nullable_datetime(
'to_create_time')
deleted = filter_params.get_as_boolean_with_default('deleted', False)
def inner(item: AccountV1):
if search is not None and not self.__match_search(item, search):
return False
if id is not None and id != item.id:
return False
if name is not None and name != item.name:
return False
if login is not None and login != item.login:
return False
if active is not None and active != item.active:
return False
if from_create_time is not None and item.create_time >= from_create_time:
return False
if to_create_time is not None and item.create_time < to_create_time:
return False
if not deleted and item.deleted:
return False
return True
return inner
def get_page_by_filter(self,
correlation_id: Optional[str],
filter: FilterParams,
paging: PagingParams,
sort=None,
select=None):
filter = filter or FilterParams()
key = filter.get_as_nullable_string('key')
filter_condition = ''
if key is not None:
filter_condition += "`key`='" + key + "'"
return super().get_page_by_filter(correlation_id, filter_condition,
paging, None, None)
def calculate_position(self, correlation_id, site_id, udis):
beacons: List[BeaconV1]
position = None
if udis is None or len(udis) == 0:
return
page = self.get_beacons(correlation_id, FilterParams.from_tuples(
'site_id', site_id,
'udis', udis
), None)
beacons = page.data if page.data else []
lat = 0
lng = 0
count = 0
for beacon in beacons:
if beacon['center'] != None and beacon['center']['type'] == "Point" and len(
beacon['center']['coordinates']) > 1:
lng = lng + beacon['center']['coordinates'][0]
lat = lat + beacon['center']['coordinates'][1]
count = count + 1
if count > 0:
position = {"type": 'Point', "coordinates": [lng / count, lat / count]}
return position
return None
def calculate_position(self, correlation_id: Optional[str], site_id: str,
udis: List[str]) -> Any:
if udis is None or len(udis) == 0:
return None
result = self.__persistence.get_page_by_filter(
correlation_id,
FilterParams.from_tuples("site_id", site_id, "udis", udis), None)
beacons = result.data
lat = 0
lng = 0
count = 0
for beacon in beacons:
if beacon.center is not None and beacon.center[
'type'] == "Point" and len(
beacon.center['coordinates']) > 1:
lng = lng + beacon.center['coordinates'][0]
lat = lat + beacon.center['coordinates'][1]
count = count + 1
if count == 0:
return None
position = {"type": 'Point', "coordinates": [lng / count, lat / count]}
return position
def calculate_position(self, correlation_id: Optional[str], site_id: str, udis: List[str]) -> Any:
beacons: List[BeaconV1] = []
position = None
if udis is None or len(udis) == 0:
return
page = self.get_beacons(correlation_id,
FilterParams.from_tuples(
'site_id', site_id,
'udis', udis
), PagingParams())
beacons = page.data or []
lat = 0
lng = 0
count = 0
for beacon in beacons:
if beacon.center is not None and beacon.center['type'] == 'Point' and isinstance(
beacon.center['coordinates'], list):
lng += beacon.center['coordinates'][0]
lat += beacon.center['coordinates'][1]
count += 1
if count > 0:
position = {
'type': 'Point',
'coordinates': [lng / count, lat / count]
}
return position or None
def get_page_by_filter(self, correlation_id, filter, paging):
filter = filter if filter is not None else FilterParams()
key = filter.get_as_nullable_string("key")
paging = paging if paging is not None else PagingParams()
skip = paging.get_skip(0)
take = paging.get_take(100)
result = []
self._lock.acquire()
try:
for item in self._items:
if key is not None and key != item['key']:
continue
skip -= 1
if skip >= 0:
continue
take -= 1
if take < 0:
break
result.append(item)
finally:
self._lock.release()
return DataPage(result, len(result))
def calculate_position(self, correlation_id, site_id, udis):
if udis == None or len(udis) == 0:
return None
result = self._persistence.get_page_by_filter(
correlation_id,
FilterParams.from_tuples("site_id", site_id, "udis", udis), None)
beacons = result.data
lat = 0
lng = 0
count = 0
for beacon in beacons:
if beacon['center'] != None and beacon['center'][
'type'] == "Point" and len(
beacon['center']['coordinates']) > 1:
lng = lng + beacon['center']['coordinates'][0]
lat = lat + beacon['center']['coordinates'][1]
count = count + 1
if count > 0:
position = {
"type": 'Point',
"coordinates": [lng / count, lat / count]
}
return position
return None
def get_page_by_filter(self, correlation_id, filter, paging):
filter = filter or FilterParams()
id = filter.get_as_nullable_string("id")
site_id = filter.get_as_nullable_string("site_id")
label = filter.get_as_nullable_string("label")
udi = filter.get_as_nullable_string("udi")
udis = filter.get_as_object("udis")
if udis != None and len(udis) > 0:
udis = udis.split(",")
def filter_beacons(item):
if id is not None and item.id != id:
return False
if site_id is not None and item.site_id != site_id:
return False
if label is not None and item.label != label:
return False
if udi is not None and item.udi != udi:
return False
if udis is not None and item.udi not in udis:
return False
return True
return super(BeaconsMemoryPersistence,
self).get_page_by_filter(correlation_id,
filter_beacons,
paging=paging)
def test_crud_operations(self):
# Create 3 beacons
self.test_create_beacons()
# Get all beacons
page = self._persistence.get_page_by_filter(None, FilterParams(),
PagingParams())
assert page is not None
assert len(page.data) == 3
beacon1 = page.data[0]
# Update the beacon
beacon1['label'] = "ABC"
beacon = self._persistence.update(None, beacon1)
assert beacon is not None
assert beacon1['id'] == beacon['id']
assert "ABC" == beacon['label']
# Get beacon by udi
beacon = self._persistence.get_one_by_udi(None, beacon1['udi'])
assert beacon is not None
assert beacon['id'] == beacon1['id']
# Delete beacon
self._persistence.delete_by_id(None, beacon1['id'])
# Try to get deleted beacon
beacon = self._persistence.get_one_by_id(None, beacon1['id'])
assert beacon is None
def compose_filter(self, filter):
filter = filter or FilterParams()
id = filter.get_as_nullable_string("id")
site_id = filter.get_as_nullable_string("site_id")
label = filter.get_as_nullable_string('label')
udi = filter.get_as_nullable_string('udi')
udis = filter.get_as_object('udis')
if type(udis) == str:
udis = udis.split(',')
if not (type(udis) == list):
udis = None
def filter_beacons(item):
if id is not None and item.id != id:
return False
if site_id is not None and item.site_id != site_id:
return False
if label is not None and item.label != label:
return False
if udi is not None and item.udi != udi:
return False
if udis is not None:
try:
udis.index(item.udi)
except Exception as e:
return False
return True
return filter_beacons
def get_page_by_filter(self, correlation_id: Optional[str],
filter: FilterParams,
paging: PagingParams) -> DataPage:
filters = filter if filter is not None else FilterParams()
key = filters.get_as_nullable_string("key")
paging = paging if not (paging is None) else PagingParams()
skip = paging.get_skip(0)
take = paging.get_take(100)
result = []
self.__lock.acquire()
try:
for item in self.__items:
if not (key is None) and key != item.key:
continue
skip -= 1
if skip >= 0: continue
take -= 1
if take < 0: break
result.append(item)
finally:
self.__lock.release()
return DataPage(result)
def _get_paging_params(self, req):
key_value_req = {}
for key, value in req.query.items:
if key in ['skip', 'take', 'total']:
key_value_req[key] = value
filter = FilterParams.from_value(key_value_req)
return filter
def __get_page_by_filter(self):
result = self._controller.get_page_by_filter(
self._get_correlation_id(),
FilterParams(bottle.request.query.dict),
PagingParams(bottle.request.query.get('skip'),
bottle.request.query.get('take'),
bottle.request.query.get('total')),
)
return self.send_result(result)
def get_page_by_filter(self, correlation_id, filter, paging):
filter = filter or FilterParams()
key = filter.get_as_nullable_string('key')
filter_condition = ''
if key is not None:
filter_condition += "data->key='" + key + "'"
return super().get_page_by_filter(correlation_id, filter_condition,
paging, None, None)
def get_page_by_filter(self,
correlation_id,
filter,
paging,
sort=None,
select=None):
filter = filter if filter != None else FilterParams()
return super(DummyMongoDbPersistence,
self).get_page_by_filter(correlation_id, filter, paging,
None, None)
def get_page_by_filter(self,
correlation_id: Optional[str],
filter: FilterParams,
paging: PagingParams,
sort: Any = None,
select: Any = None) -> DataPage:
filter = filter if filter is not None else FilterParams()
return super(BeaconsMongoDbPersistence,
self).get_page_by_filter(correlation_id,
self.compose_filter(filter),
paging, None, None)
def __compose_filter(self, filter_params: FilterParams) -> Callable:
filter_params = filter_params or FilterParams()
id = filter_params.get_as_nullable_string('id')
site_id = filter_params.get_as_nullable_string('site_id')
label = filter_params.get_as_nullable_string('label')
udi = filter_params.get_as_nullable_string('udi')
udis = filter_params.get_as_object('udis')
if isinstance(udis, str):
udis = udis.split(',')
if not isinstance(udis, list):
udis = None
def inner(item):
if id is not None and item.id != id:
return False
if site_id is not None and item.site_id != site_id:
return False
if label is not None and item.label != label:
return False
if udi is not None and item.udi != udi:
return False
if udis is not None and udis.count(item.udi) < 0:
return False
return True
return inner
def __compose_filter(self, filter: FilterParams) -> Callable:
filter = filter if filter is not None else FilterParams()
id = filter.get_as_nullable_string("id")
site_id = filter.get_as_nullable_string("site_id")
label = filter.get_as_nullable_string("label")
udi = filter.get_as_nullable_string("udi")
udis = filter.get_as_object("udis")
if udis is not None and len(udis) > 0:
udis = udis.split(",")
def filter_beacons(item):
if id is not None and item.id != id:
return False
if site_id is not None and item.site_id != site_id:
return False
if label is not None and item.label != label:
return False
if udi is not None and item.udi != udi:
return False
if udis is not None and item.udi not in udis:
return False
return True
return filter_beacons
def get_page_by_filter(self, correlation_id, filter, paging):
filter = filter if filter != None else FilterParams()
key = filter.get_as_nullable_string("key")
def filter_dummy(obj):
if key != None and obj['key'] != key:
return False
return True
return super(DummyMemoryPersistence,
self).get_page_by_filter(correlation_id,
filter_dummy,
paging=paging)
def test_crud_operations(self):
# Create the first beacon
beacon1 = self._controller.create_beacon(None, BEACON1)
assert beacon1 != None
assert beacon1['id'] == BEACON1['id']
assert beacon1['site_id'] == BEACON1['site_id']
assert beacon1['udi'] == BEACON1['udi']
assert beacon1['type'] == BEACON1['type']
assert beacon1['label'] == BEACON1['label']
assert beacon1['center'] != None
# Create the second beacon
beacon2 = self._controller.create_beacon(None, BEACON2)
assert beacon2 != None
assert beacon2['id'] == BEACON2['id']
assert beacon2['site_id'] == BEACON2['site_id']
assert beacon2['udi'] == BEACON2['udi']
assert beacon2['type'] == BEACON2['type']
assert beacon2['label'] == BEACON2['label']
assert beacon2['center'] != None
# Get all beacons
page = self._controller.get_beacons_by_filter(None, FilterParams(),
PagingParams())
assert page != None
assert len(page.data) == 2
beacon1 = page.data[0]
# Update the beacon
beacon1['label'] = "ABC"
beacon = self._controller.update_beacon(None, beacon1)
assert beacon != None
assert beacon1['id'] == beacon['id']
assert "ABC" == beacon['label']
# Get beacon by udi
beacon = self._controller.get_beacon_by_udi(None, beacon1['udi'])
assert beacon != None
assert beacon['id'] == beacon1['id']
# Delete beacon
self._controller.delete_beacon_by_id(None, beacon1['id'])
# Try to get deleted beacon
beacon = self._controller.get_beacon_by_id(None, beacon1['id'])
assert beacon == None
def test_crud_operations(self):
# Create the first beacon
beacon1 = self._controller.create_beacon(None, BEACON1)
assert beacon1 is not None
assert beacon1.id == BEACON1.id
assert beacon1.site_id == BEACON1.site_id
assert beacon1.udi == BEACON1.udi
assert beacon1.type == BEACON1.type
assert beacon1.label == BEACON1.label
assert beacon1.center is not None
# Create the second beacon
beacon2 = self._controller.create_beacon(None, BEACON2)
assert beacon2 != None
assert beacon2.id == BEACON2.id
assert beacon2.site_id == BEACON2.site_id
assert beacon2.udi == BEACON2.udi
assert beacon2.type == BEACON2.type
assert beacon2.label == BEACON2.label
assert beacon2.center is not None
# Get all beacons
page = self._controller.get_beacons_by_filter(None, FilterParams(),
PagingParams())
assert page is not None
assert len(page.data) == 2
beacon1 = page.data[0]
# Update the beacon
beacon1.label = "ABC"
beacon = self._controller.update_beacon(None, beacon1)
assert beacon is not None
assert beacon1.id == beacon.id
assert "ABC" == beacon.label
# Get beacon by udi
beacon = self._controller.get_beacon_by_udi(None, beacon1.udi)
assert beacon is not None
assert beacon.id == beacon1.id
# Delete beacon
self._controller.delete_beacon_by_id(None, beacon1.id)
# Try to get deleted beacon
beacon = self._controller.get_beacon_by_id(None, beacon1.id)
assert beacon is None
def test_crud_operations(self):
# Create one dummy
dummy1 = self._client.create(None, DUMMY1)
assert dummy1 is not None
assert dummy1.id is not None
assert DUMMY1.key == dummy1.key
assert DUMMY1.content == dummy1.content
# Create another dummy
dummy2 = self._client.create(None, DUMMY2)
assert dummy2 is not None
assert dummy2.id is not None
assert DUMMY2.key == dummy2.key
assert DUMMY2.content == dummy2.content
# Get all dummies
dummies = self._client.get_page_by_filter(None, FilterParams(),
PagingParams(0, 5, False))
assert dummies is not None
assert len(dummies.data) >= 2
# Update the dummy
dummy1.content = "Updated Content 1"
dummy = self._client.update(None, dummy1)
assert dummy is not None
assert dummy1.id == dummy.id
assert dummy1.key == dummy.key
assert "Updated Content 1" == dummy.content
# Delete the dummy
self._client.delete_by_id(None, dummy1.id)
# Try to get deleted dummy
dummy = self._client.get_one_by_id(None, dummy1.id)
assert dummy is None
# Check correlation id
result = self._client.check_correlation_id('test_cor_id')
assert result is not None
assert 'test_cor_id' == result
def compose_filter(self, filter):
filter = filter or FilterParams()
criteria = []
id = filter.get_as_nullable_string("id")
if id is not None:
criteria.append({"_id": id})
site_id = filter.get_as_nullable_string("site_id")
if site_id is not None:
criteria.append({"site_id": site_id})
label = filter.get_as_nullable_string("label")
if label is not None:
criteria.append({"label": label})
udi = filter.get_as_nullable_string("udi")
if udi is not None:
criteria.append({"udi": udi})
udis = filter.get_as_object("udis")
if udis is not None and len(udis) > 0:
udis = udis.split(",")
criteria.append({"udi": {"$in": udis}})
return {"$and": criteria} if len(criteria) > 0 else None
def __compose_filter(self, filter_params: FilterParams) -> Callable:
filter_params = filter_params or FilterParams()
id = filter_params.get_as_nullable_string('id')
ids = filter_params.get_as_object('ids')
except_ids = filter_params.get_as_object('except_ids')
roles = filter_params.get_as_object('roles')
except_roles = filter_params.get_as_object('except_roles')
# Process ids filter
if isinstance(ids, str):
ids = ids.split(',')
if not isinstance(ids, list):
ids = None
# Process except ids filter
if isinstance(except_ids, str):
except_ids = except_ids.split(',')
if isinstance(except_ids, list):
except_ids = None
# Process roles filter
if isinstance(roles, str):
roles = roles.split(',')
if isinstance(roles, list):
except_ids = None
# Process except roles filter
if isinstance(except_roles, str):
except_roles = except_roles.split(',')
if isinstance(except_roles, list):
except_ids = None
def inner(item):
if id and item.id != id:
return False
if ids and ids.count(item.id) < 0:
return False
if except_ids and except_ids.count(item.id) >= 0:
return False
if roles and not self.__contains(roles, item.roles):
return False
if except_roles and self.__contains(except_roles, item.roles):
return False
return True
return inner
def __compose_filter(self, filter_params: FilterParams) -> Callable:
filter_params = filter_params or FilterParams()
search = filter_params.get_as_nullable_string('search')
id = filter_params.get_as_nullable_string('id')
code = filter_params.get_as_nullable_string('code')
active = filter_params.get_as_nullable_boolean('active')
deleted = filter_params.get_as_boolean_with_default('deleted', False)
def inner(item):
if id and item.id != id:
return False
if code and item.code != code:
return False
if active and item.active != active:
return False
if not deleted and item.deleted:
return False
if search and not self.__match_search(item, search):
return False
return True
return inner
def handler(correlation_id, args):
filter = FilterParams.from_value(args.get("filter"))
paging = PagingParams.from_value(args.get("paging"))
return self._controller.get_beacons_by_filter(
correlation_id, filter, paging)
