def get(self, request, *args, **kwargs):
validation = self.extract_request(request)
if validation:
return self.api_response({'error': validation})
# get data
if 'extent' in request.GET:
polygon = parse_bbox(request.GET.get('extent'))
# if page is not presented, use page = 1
page = self.page
if not page:
page = 1
facilities = self.get_query_by_page(
get_heathsites_master().in_polygon(polygon), page)
facilities = self.query_to_json(facilities, self.format)
return self.api_response(facilities)
elif 'page' in request.GET:
if not self.page:
return self.api_response({'error': "page is wrong type"})
facilities = self.get_query_by_page(get_heathsites_master(),
self.page)
facilities = self.query_to_json(facilities, self.format)
return self.api_response(facilities)
else:
return self.api_response({'error': "need parameter"})
def get_healthsites(self, request):
# check extent data
extent = request.GET.get('extent', None)
queryset = LocalityOSMView.objects.all()
if extent:
try:
polygon = parse_bbox(request.GET.get('extent'))
except (ValueError, IndexError):
raise BadRequestError('extent is incorrect format')
queryset = queryset.in_polygon(polygon)
# check by country
country = request.GET.get('country', None)
if country == 'World':
country = None
if country:
# getting country's polygon
try:
country = Country.objects.get(
name__iexact=country)
polygons = country.polygon_geometry
queryset = queryset.in_polygon(polygons)
except Country.DoesNotExist:
raise BadRequestError('%s is not found or not a country.' % country)
return queryset
def get(self, request, *args, **kwargs):
validation = self.extract_request(request)
if validation:
return self.api_response(
{'error': validation}
)
# get data
if 'extent' in request.GET:
polygon = parse_bbox(request.GET.get('extent'))
# if page is not presented, use page = 1
page = self.page
if not page:
page = 1
facilities = self.get_query_by_page(
get_heathsites_master().in_polygon(polygon), page
)
facilities = self.query_to_json(facilities, self.format)
return self.api_response(facilities)
elif 'page' in request.GET:
if not self.page:
return self.api_response(
{'error': 'page is wrong type'}
)
facilities = self.get_query_by_page(get_heathsites_master(), self.page)
facilities = self.query_to_json(facilities, self.format)
return self.api_response(facilities)
else:
return self.api_response(
{'error': 'need parameter'}
)
def get_healthsites(self, request):
# check extent data
extent = request.GET.get('extent', None)
queryset = LocalityOSMView.objects.all()
if extent:
try:
polygon = parse_bbox(request.GET.get('extent'))
except (ValueError, IndexError):
raise BadRequestError('extent is incorrect format')
queryset = queryset.in_polygon(polygon)
# check by country
country = request.GET.get('country', None)
if country == 'World':
country = None
if country:
# getting country's polygon
try:
country = Country.objects.get(name__iexact=country)
polygons = country.polygon_geometry
queryset = queryset.in_polygon(polygons)
except Country.DoesNotExist:
raise BadRequestError('%s is not found or not a country.' %
country)
return queryset
def get(self, request, *args, **kwargs):
super(LocalitySearchApiView, self).get(request)
if not 'name' in request.GET or not 'search_type' in request.GET:
return HttpResponse(
self.formating_response({'error': "parameter is not enough"}),
content_type='application/json')
place_name = request.GET['name']
search_type = request.GET['search_type']
if not place_name:
return HttpResponse(
self.formating_response({'error': "place name parameter can't be empty"}),
content_type='application/json')
if search_type == "placename":
try:
country = Country.objects.get(name__icontains=place_name)
polygon = country.polygon_geometry
except Country.DoesNotExist:
# if country is not found
output = search_place(request, place_name)
output['countries'] = ""
bbox = output["southwest_lng"] + "," + output["southwest_lat"] + "," + output["northeast_lng"] + "," + \
output["northeast_lat"]
try:
polygon = parse_bbox(bbox)
except ValueError:
return HttpResponse(
self.formating_response({'error': "place is not found"}),
content_type='application/json')
if 'facility_type' in request.GET:
facility_type = request.GET['facility_type']
else:
facility_type = ""
facilities = self.get_healthsite_master_by_polygon(polygon, facility_type)
return HttpResponse(
self.formating_response(facilities),
content_type='application/json')
elif search_type == "facility":
facilities = Locality.objects.filter(name__icontains=place_name)
facilities_dict = []
for healthsite in facilities:
if self.format == 'geojson':
facilities_dict.append(geojson_serializer(healthsite))
else:
facilities_dict.append(json_serializer(healthsite))
return HttpResponse(
self.formating_response(facilities_dict),
content_type='application/json')
else:
return HttpResponse(
self.formating_response({'error': "search type is wrong"}),
content_type='application/json')
def filter_locality(extent=None,
country=None,
timestamp_from=None,
timestamp_to=None,
place=None):
""" Filter osm locality by extent and country
:param extent: extent of data
:type extent: str (with comma separator)
:param country: specific country
:type country: str
:param timestamp_from: start time
:type timestamp_from: timestamp
:param timestamp_to: end time
:type timestamp_to: timestamp
:return: LocalityOSMView
"""
# check extent data
queryset = all_locality()
if extent:
try:
polygon = parse_bbox(extent)
except (ValueError, IndexError):
raise Exception('extent is incorrect format')
queryset = queryset.in_polygon(polygon)
# check by country
if country:
try:
# getting country's polygon
country = Country.objects.get(name__iexact=country)
if country:
polygons = country.polygon_geometry
queryset = queryset.in_polygon(polygons)
except Country.DoesNotExist:
raise Exception('%s is not found or not a country.' % country)
if place:
try:
geo = search_by_geoname(place)
bbox = (geo['southwest']['lng'], geo['southwest']['lat'],
geo['northeast']['lng'], geo['northeast']['lat'])
geom = Polygon.from_bbox(bbox)
queryset = queryset.filter(geometry__within=geom)
except Exception:
pass
if timestamp_from:
queryset = queryset.filter(changeset_timestamp__gte=timestamp_from)
if timestamp_to:
queryset = queryset.filter(changeset_timestamp__lte=timestamp_to)
return queryset
def get(self, request, *args, **kwargs): # NOQA
validation = self.extract_request(request)
if validation:
return self.api_response({'error': validation})
if 'name' not in request.GET or 'search_type' not in request.GET:
return self.api_response({'error': 'parameter is not enough'})
place_name = request.GET['name']
search_type = request.GET['search_type']
if search_type == 'placename':
try:
countries = Country.objects.filter(name__icontains=place_name)
if len(countries) == 0:
raise Country.DoesNotExist
country = None
for country_query in countries:
if not country:
country = country_query
else:
if len(country.name) > len(country_query.name):
country = country_query
polygon = country.polygon_geometry
except Country.DoesNotExist:
# if country is not found
output = search_place(request, place_name)
output['countries'] = ''
bbox = (output['southwest_lng'] + ',' +
output['southwest_lat'] + ',' +
output['northeast_lng'] + ',' +
output['northeast_lat'])
try:
polygon = parse_bbox(bbox)
except ValueError:
return self.api_response({'error': 'place is not found'})
facility_type = ''
if 'facility_type' in request.GET:
facility_type = request.GET['facility_type']
facilities = self.get_healthsite_master_by_polygon(
polygon, facility_type)
facilities = self.query_to_json(facilities, self.format)
return self.api_response(facilities)
elif search_type == 'facility':
facilities = Locality.objects.filter(name__icontains=place_name)
if self.page:
facilities = self.get_query_by_page(facilities, self.page)
else:
facilities = facilities[:100]
facilities = self.query_to_json(facilities, self.format)
return self.api_response(facilities)
else:
return self.api_response({'error': 'search type is wrong'})
def _parse_request_params(self, request):
if not(all(param in request.GET for param in ['bbox'])):
raise Http404
try:
bbox_poly = parse_bbox(request.GET.get('bbox'))
except:
# return 404 if any of parameters are missing or not parsable
raise Http404
return bbox_poly
def _parse_request_params(self, request):
if not (all(param in request.GET for param in ['bbox'])):
raise Http404
try:
bbox_poly = parse_bbox(request.GET.get('bbox'))
except:
# return 404 if any of parameters are missing or not parsable
raise Http404
return bbox_poly
def handle(self, *args, **options):
if len(args) != 2:
icon_size = self.default_size
else:
try:
icon_size = [int(size) for size in args[0:2]]
except Exception as e:
raise CommandError(str(e))
if any((size < 0 for size in icon_size)):
# icon sizes should be positive
raise CommandError('Icon sizes should be positive numbers')
# check the folder
if not os.path.exists(settings.CLUSTER_CACHE_DIR):
os.makedirs(settings.CLUSTER_CACHE_DIR)
for zoom in range(settings.CLUSTER_CACHE_MAX_ZOOM + 1):
filename = os.path.join(
settings.CLUSTER_CACHE_DIR,
'{}_{}_{}_localities.json'.format(zoom, *icon_size)
)
localities = get_heathsites_master().in_bbox(parse_bbox('-180,-90,180,90'))
object_list = cluster(localities, zoom, *icon_size)
with open(filename, 'wb') as cache_file:
json.dump(object_list, cache_file)
self.stdout.write('Generated cluster cache for zoom: %s' % zoom)
for country in Country.objects.all():
self.stdout.write('Generating cluster for %s' % country.name)
polygon = country.polygon_geometry
localities = get_heathsites_master().in_polygon(polygon)
for zoom in range(settings.CLUSTER_CACHE_MAX_ZOOM + 1):
filename = os.path.join(
settings.CLUSTER_CACHE_DIR,
'{}_{}_{}_localities_{}.json'.format(
zoom, icon_size[0], icon_size[1], country.name.encode('ascii', 'ignore')
)
)
object_list = cluster(localities, zoom, *icon_size)
with open(filename, 'wb') as cache_file:
json.dump(object_list, cache_file)
self.stdout.write('Generated cluster cache for zoom: %s' % zoom)
def handle(self, *args, **options):
if len(args) != 2:
icon_size = self.default_size
else:
try:
icon_size = [int(size) for size in args[0:2]]
except Exception as e:
raise CommandError(str(e))
if any((size < 0 for size in icon_size)):
# icon sizes should be positive
raise CommandError('Icon sizes should be positive numbers')
# check the folder
if not os.path.exists(settings.CLUSTER_CACHE_DIR):
os.makedirs(settings.CLUSTER_CACHE_DIR)
for zoom in range(settings.CLUSTER_CACHE_MAX_ZOOM + 1):
filename = os.path.join(
settings.CLUSTER_CACHE_DIR,
'{}_{}_{}_localities.json'.format(zoom, *icon_size)
)
localities = get_heathsites_master().in_bbox(parse_bbox('-180,-90,180,90'))
object_list = cluster(localities, zoom, *icon_size)
with open(filename, 'wb') as cache_file:
json.dump(object_list, cache_file)
self.stdout.write('Generated cluster cache for zoom: %s' % zoom)
for country in Country.objects.all():
self.stdout.write('Generated cluster for %s' % country.name)
polygon = country.polygon_geometry
localities = get_heathsites_master().in_polygon(polygon)
for zoom in range(settings.CLUSTER_CACHE_MAX_ZOOM + 1):
filename = os.path.join(
settings.CLUSTER_CACHE_DIR,
'{}_{}_{}_localities_{}.json'.format(
zoom, icon_size[0], icon_size[1], country.name
)
)
object_list = cluster(localities, zoom, *icon_size)
with open(filename, 'wb') as cache_file:
json.dump(object_list, cache_file)
self.stdout.write('Generated cluster cache for zoom: %s' % zoom)
def get(self, request):
validation = self.validation()
if validation:
return HttpResponseBadRequest(validation)
# check extent data
extent = request.GET.get('extent', None)
queryset = LocalityOSMView.objects.all()
if extent:
try:
polygon = parse_bbox(request.GET.get('extent'))
except (ValueError, IndexError):
return HttpResponseBadRequest('extent is incorrect format')
queryset = queryset.in_polygon(polygon)
queryset = self.get_query_by_page(queryset)
return Response(self.serialize(queryset, many=True))
def get(self, request):
validation = self.validation()
if validation:
return HttpResponseBadRequest(validation)
# check extent data
extent = request.GET.get('extent', None)
queryset = LocalityOSMView.objects.all()
if extent:
try:
polygon = parse_bbox(request.GET.get('extent'))
except (ValueError, IndexError):
return HttpResponseBadRequest('extent is incorrect format')
queryset = queryset.in_polygon(polygon)
queryset = self.get_query_by_page(queryset)
return Response(self.serialize(queryset, many=True))
def get(self, request, *args, **kwargs):
super(FacilitiesApiView, self).get(request)
# checking page
if 'page' not in request.GET:
page = None
else:
try:
page = request.GET.get('page')
page = int(page)
if page == 0:
return HttpResponse(self.formating_response(
{'error': "page less than 1"}),
content_type='application/json')
except ValueError:
return HttpResponse(self.formating_response(
{'error': "page is not a number"}),
content_type='application/json')
# get data
if 'extent' in request.GET:
polygon = parse_bbox(request.GET.get('extent'))
if not page:
page = 1
facilities = self.get_heathsites_by_page(
get_heathsites_master().in_polygon(polygon), page)
return HttpResponse(self.formating_response(facilities),
content_type='application/json')
elif 'page' in request.GET:
if not page:
return HttpResponse(self.formating_response(
{'error': "page is wrong type"}),
content_type='application/json')
facilities = self.get_heathsites_by_page(get_heathsites_master(),
page)
return HttpResponse(self.formating_response(facilities),
content_type='application/json')
else:
return HttpResponse(self.formating_response(
{'error': "need parameter"}),
content_type='application/json')
def get(self, request, *args, **kwargs): # NOQA
validation = self.extract_request(request)
if validation:
return self.api_response(
{'error': validation}
)
if 'name' not in request.GET or 'search_type' not in request.GET:
return self.api_response(
{'error': 'parameter is not enough'}
)
place_name = request.GET['name']
search_type = request.GET['search_type']
if search_type == 'placename':
try:
countries = Country.objects.filter(
name__icontains=place_name
)
if len(countries) == 0:
raise Country.DoesNotExist
country = None
for country_query in countries:
if not country:
country = country_query
else:
if len(country.name) > len(country_query.name):
country = country_query
polygon = country.polygon_geometry
except Country.DoesNotExist:
# if country is not found
output = search_place(request, place_name)
output['countries'] = ''
bbox = '%s,%s,%s,%s' % (
output['southwest_lng'], output['southwest_lat'],
output['northeast_lng'], output['northeast_lat']
)
try:
polygon = parse_bbox(bbox)
except ValueError:
return self.api_response(
{'error': 'place is not found'}
)
facility_type = ''
if 'facility_type' in request.GET:
facility_type = request.GET['facility_type']
facilities = self.get_healthsite_master_by_polygon(polygon, facility_type)
facilities = self.query_to_json(facilities, self.format)
return self.api_response(facilities)
elif search_type == 'facility':
facilities = Locality.objects.filter(name__icontains=place_name)
if self.page:
facilities = self.get_query_by_page(facilities, self.page)
else:
facilities = facilities[:100]
facilities = self.query_to_json(facilities, self.format)
return self.api_response(facilities)
else:
return self.api_response(
{'error': 'search type is wrong'}
)
def get(self, request, *args, **kwargs):
validation = self.extract_request(request)
if validation:
return self.api_response(
{'error': validation}
)
if not 'name' in request.GET or not 'search_type' in request.GET:
return self.api_response(
{'error': "parameter is not enough"}
)
place_name = request.GET['name']
search_type = request.GET['search_type']
if search_type == "placename":
try:
countries = Country.objects.filter(
name__icontains=place_name
)
if len(countries) == 0:
raise Country.DoesNotExist
country = None
for country_query in countries:
if not country:
country = country_query
else:
if len(country.name) > len(country_query.name):
country = country_query
polygon = country.polygon_geometry
except Country.DoesNotExist:
# if country is not found
output = search_place(request, place_name)
output['countries'] = ""
bbox = output["southwest_lng"] + "," + \
output["southwest_lat"] + "," + \
output["northeast_lng"] + "," + \
output["northeast_lat"]
try:
polygon = parse_bbox(bbox)
except ValueError:
return self.api_response(
{'error': "place is not found"}
)
facility_type = ""
if 'facility_type' in request.GET:
facility_type = request.GET['facility_type']
facilities = self.get_healthsite_master_by_polygon(polygon, facility_type)
facilities = self.query_to_json(facilities, self.format)
return self.api_response(facilities)
elif search_type == "facility":
facilities = Locality.objects.filter(name__icontains=place_name)
facilities = self.query_to_json(facilities, self.format)
return self.api_response(facilities)
else:
return self.api_response(
{'error': "search type is wrong"}
)
