def get(self, request):
point_of_user = GEOSGeometry("POINT({} {})".format(
-106.3911803, 31.6482147))
point_to_go = GEOSGeometry("POINT({} {})".format(
-106.354794, 31.627863))
max_distance = 250 # m
coordendadas = RutaCoordenda.objects.filter(
coordenadas__distance_lt=(point_of_user, Distance(
m=max_distance)), ).annotate(distance=qDistance(
'coordenadas', point_of_user)).distinct("ruta")
ids = []
for coordendada in coordendadas:
print coordendada
ids.append(coordendada.ruta_id)
coordendadas2 = RutaCoordenda.objects.filter(
coordenadas__distance_lt=(point_to_go, Distance(m=max_distance)),
ruta__id__in=ids).annotate(distance=qDistance(
'coordenadas', point_to_go)).distinct("ruta")
ruta = None
for coordendada in coordendadas2:
# print "salgo", coordendada.distance, coordendada
ruta = coordendada.ruta
return render(request, self.template_name, context={"ruta": ruta})
def filter_queryset(self, queryset):
# Apply any filter backends
filters = {}
for field in self.lookup_fields:
if self.kwargs[field]: # Ignore empty fields.
filters[field] = self.kwargs[field]
obj = get_object_or_404(User.objects.all(),
**filters) # Lookup the object
radius = int(self.request.query_params['radius'])
if radius > 100:
raise serializers.ValidationError("To high radius")
if (obj.usertype == 'HF'):
data = User.objects.filter(
usertype='HFS',
public=False,
location__distance_lte=(obj.location, Distance(km=radius)))
else:
data = User.objects.filter(
usertype='HF',
public=False,
location__distance_lte=(obj.location, Distance(km=radius)))
if (validsessionid(obj)):
self.check_object_permissions(self.request, obj)
return data
raise serializers.ValidationError("Invalid Sessionid")
def format_meters(value, unit):
if unit == 'km':
return '{:.2f} km'.format(Distance(m=value).km)
if unit == 'mi':
return '{:.2f} miles'.format(Distance(m=value).mi)
return '{:.2f} meters'.format(Distance(m=value).m)
def validate_buffer(wkb_geometry, apiary_sites_to_exclude=None):
"""
This function checks if the wkb_geometry (point) is at least 3km away from the other apiary sites
@param wkb_geometry: WKB geometry of a point
@param apiary_sites_to_exclude: List or queryset of the apiary sites to be excluded when validation
"""
if not apiary_sites_to_exclude:
from disturbance.components.proposals.models import ApiarySite
apiary_sites_to_exclude = ApiarySite.objects.none()
site_too_close_error = serializers.ValidationError([
'Apiary Site: (lat: {}, lng: {}) is too close to another apiary site.'.
format(
wkb_geometry.coords[1],
wkb_geometry.coords[0],
)
])
qs_vacant_site_proposal, qs_vacant_site_approval = get_qs_vacant_site()
sites = qs_vacant_site_proposal.exclude(
apiary_site__in=apiary_sites_to_exclude).filter(
Q(wkb_geometry_processed__distance_lte=(wkb_geometry,
Distance(
m=RESTRICTED_RADIUS))))
if sites:
raise site_too_close_error
sites = qs_vacant_site_approval.exclude(
apiary_site__in=apiary_sites_to_exclude).filter(
Q(wkb_geometry__distance_lte=(wkb_geometry,
Distance(m=RESTRICTED_RADIUS))))
if sites:
raise site_too_close_error
#qs_on_proposal_draft, qs_on_proposal_processed = get_qs_proposal()
qs_on_proposal_draft = get_qs_proposal('draft')
qs_on_proposal_processed = get_qs_proposal('processed')
sites = qs_on_proposal_draft.exclude(
apiary_site__in=apiary_sites_to_exclude).filter(
Q(wkb_geometry_draft__distance_lte=(wkb_geometry,
Distance(
m=RESTRICTED_RADIUS))))
if sites:
raise site_too_close_error
sites = qs_on_proposal_processed.exclude(
apiary_site__in=apiary_sites_to_exclude).filter(
Q(wkb_geometry_processed__distance_lte=(wkb_geometry,
Distance(
m=RESTRICTED_RADIUS))))
if sites:
raise site_too_close_error
qs_on_approval = get_qs_approval()
sites = qs_on_approval.exclude(
apiary_site__in=apiary_sites_to_exclude).filter(
Q(wkb_geometry__distance_lte=(wkb_geometry,
Distance(m=RESTRICTED_RADIUS))))
if sites:
raise site_too_close_error
def get_queryset(self):
queryset = Ad.objects.all()
# not detail page
if not self.kwargs.get('pk'):
queryset = queryset.filter(is_published=True, region__isnull=0)
if self.request.query_params.get('own', None) is not None:
if self.request.user.is_authenticated():
queryset = Ad.objects.filter(user=self.request.user.id)
else:
queryset = Ad.objects.none()
lon = float(self.request.query_params.get('lon') or 0)
lat = float(self.request.query_params.get('lat') or 0)
radius = float(self.request.query_params.get('radius') or 5)
if lon and lat:
if settings.MESTO_USE_GEODJANGO:
distance_filters = make_sphere_distance_filters(
'point', Point(lon, lat, srid=4326), Distance(km=radius))
else:
distance_filters = make_coords_ranges_filters(
(lon, lat), Distance(km=radius))
queryset = queryset.filter(**distance_filters)
region_id = self.request.query_params.get('region', None)
if region_id is not None:
region = Region.objects.get(pk=region_id)
queryset = queryset.filter(region__in=region.get_descendants(True))
min_price = int(self.request.query_params.get('min_price') or 0)
max_price = int(self.request.query_params.get('max_price') or 0)
if min_price or max_price:
curr_rate = 1
currency = self.request.query_params.get('currency', None)
if currency:
curr_rate = get_currency_rates()[currency]
if min_price > 0:
queryset = queryset.filter(price_uah__gte=min_price *
curr_rate)
if max_price > 0:
queryset = queryset.filter(price_uah__lte=max_price *
curr_rate)
queryset = queryset.prefetch_related('region', 'phones_in_ad',
'phones', 'photos', 'facilities',
'user', 'user__agencies')
return queryset
def validate_similar(self):
# 1. Location within buffer
# 2. Fuzzy match site name
pk = self.instance.pk
project_id = self.instance.project_id
name = self.instance.name
location = self.instance.location
# Ignore self and ensure same project
qry = self.model.objects.filter(~Q(id=pk))
qry = qry.filter(project_id=project_id)
if location is not None:
qry = qry.filter(
location__distance_lt=(location, Distance(m=self.site_buffer)))
# Fuzzy name match
qry = qry.annotate(similarity=TrigramSimilarity("name", name))
qry = qry.filter(similarity__gte=self.name_match_percent)
qry = qry.order_by("-similarity")
results = qry[0:3]
if results.count() > 0:
matches = [r.id for r in results]
data = dict(matches=matches)
return self.warning(self.identifier,
_(LikeMatchWarning.format(self.name)),
data=data)
return self.ok(self.identifier)
def parcel_info(request, **kwargs):
lat = float(kwargs['lat'])
lng = float(kwargs['long'])
point = Point(lng, lat)
radius = 0.7
parcelz = serialize(
'geojson',
ParcelInfo.objects.filter(geom__distance_lt=(point,
Distance(km=radius))))
trial = json.loads(parcelz)
ids = [element['properties']['parcelid'] for element in trial['features']]
queryset = serialize(
'json',
History.objects.filter(parcelid__in=ids).order_by('-date'))
letsee = json.loads(queryset)
for i in trial['features']:
id_ = i['properties']['parcelid']
i['properties']['history'] = [
x for x in letsee if x['fields']['parcelid'] == id_
]
# print(queryset)
# things = [json.loads(line) for line in f]
# i['properties']['history'] = queryset
new = json.dumps(trial)
return HttpResponse(new, content_type='json')
def get(self, request):
# Request must be authorized
if not request.user.is_authenticated:
return Response('User not authenticated!',
status=status.HTTP_401_UNAUTHORIZED)
events = Event.objects.all()
# if author filter
author = request.query_params.get('author')
if author:
events = events.filter(author=int(author))
# if category filter
category = request.query_params.get('category')
if category:
events = events.filter(category=int(category))
# if geo_location filter
lat = request.query_params.get('lat')
lon = request.query_params.get('lon')
radius = request.query_params.get('r')
if lat and lon and radius:
events = events.filter(
geo_location__distance_lt=(Point(float(lon), float(lat)),
Distance(km=radius)))
serializer = EventSerializer(events, many=True)
# Remove geo_location from response
for s in serializer.data:
s.pop('geo_location')
return Response(serializer.data)
def build_filters(self, filters=None):
if filters is None:
filters = {}
orm_filters = super(ProductResource, self).build_filters(filters)
if "q" in filters or "l" in filters:
sqs = product_search
if "q" in filters:
sqs = sqs.auto_query(filters['q'])
if "l" in filters:
name, coords, radius = GoogleGeocoder().geocode(filters['l'])
if all(coords):
radius = filters.get('r',
radius if radius else DEFAULT_RADIUS)
point = Point(coords)
sqs = sqs.dwithin(
'location', point,
Distance(km=radius)) #.distance('location', point)
pk = []
for p in sqs:
try:
pk.append(int(p.pk))
except ValueError:
pass
orm_filters.update({"pk__in": pk})
return orm_filters
def filter_queryset(self, request, queryset, view):
nearby_pk = request.query_params.get('nearby_pk', None)
if nearby_pk is not None:
point = models.Request.objects.get(pk=nearby_pk).location
return queryset.filter(location__distance_lt=(point, Distance(
km=10))).order_by('pk')
return queryset
def result2(request, lat, lon='33.00'):
if float(lat)<-180 or float(lat)>180:
return HttpResponseBadRequest('Error 400')
#return HttpResponse(status=400)
#AEN: THIS DOESN'T WORK! Maybe it was, but was just sending an empty page. I WANT THE DEFAULT!
#raise Http404; #This SHOULD be 400
pt = Point(float(lon), float(lat))
country = WorldBorder.objects.filter(mpoly__contains=pt)
countriesNearUS = filter(lambda x:x.closeToUS(), WorldBorder.objects.all())
if not country:
context = {'lat':lat, 'lon':lon,
'countriesNearUnitedStates':countriesNearUS}
return render(request, 'world/result.html', context)
d=Distance(m=500)
touching = WorldBorder.objects.filter(mpoly__touches=country[0].mpoly)
### neighbors = WorldBorder.objects.filter(mpoly__distance_lte=(country[0].mpoly, d))
### neighbors = filter(lambda x: x.id!=country[0].id, neighbors)
t = tasks.getArea.delay(country[0].id)
t.wait(); #This should be something far more complicated, like a long pull,Perhaps USING rabbitmq to check based on the task.id!
area = str(t.result)
context = {'country':country, 'lat':lat, 'lon':lon,
'touching':touching, 'neighbors':[],
'distance':d, 'area':area,
'countriesNearUnitedStates':countriesNearUS}
return render(request, 'world/result.html', context)
'''if not country:
def to_python(self, value):
if value in self.empty_values:
return None
try:
obj = json.loads(value)
except JSONDecodeError:
raise DjangoValidationError(self.default_error_messages['invalid_json'], code='invalid_json')
if set(obj) != {'max_distance', 'coordinates'}:
raise DjangoValidationError(self.default_error_messages['invalid_fields'], code='invalid_fields')
max_distance = obj['max_distance']
coordinates = obj['coordinates']
try:
max_distance = float(max_distance)
except ValueError:
raise DjangoValidationError(self.default_error_messages['invalid_max_distance'], code='invalid_max_distance')
if not check_coordinates(coordinates):
raise DjangoValidationError(self.default_error_messages['invalid_coordinates'], code='invalid_coordinates')
return Point(*coordinates), Distance(m=max_distance)
def test_dwitihin(self, search_queryset):
sqs = search_queryset
latlong = (0.4, 5.1)
list(sqs.dwithin('location', Point(latlong), Distance(km=10)))
assert search_params.params['aroundLatLng'] == "0.4,5.1"
assert search_params.params['aroundRadius'] == 10000
def validate_value(self, view, field, value, expected_value_type=None):
value = super().validate_value(view, field, value, expected_value_type)
if 'longitude' not in value or 'latitude' not in value:
raise InvalidQuery(self.default_error.format(lookup=self.lookup, field_name=field.name))
longitude, latitude = value['longitude'], value['latitude']
if not self._check_number(longitude, (-180, 180)) or not self._check_number(latitude, (-90, 90)):
raise InvalidQuery('Invalid longitude/latitude values.')
# Default distance is 100 miles
distance_unit = 'mi'
distance = 100
max_distance = None
if 'distance_in_miles' in value:
distance = value['distance_in_miles']
# Equator length is 24901 miles
max_distance = 24901
elif 'distance_in_kilometers' in value:
distance = value['distance_in_kilometers']
distance_unit = 'km'
# Equator length is 40075 km
max_distance = 40075
if max_distance is not None and not self._check_number(distance, (0, max_distance), inclusive=True):
raise InvalidQuery('Invalid distance value.')
return Point(longitude, latitude), Distance(**{distance_unit: distance})
def nearest_stores(request):
longitude = float(request.POST.get('longitude'))
latitude = float(request.POST.get('latitude'))
longitude = 76.702074
latitude = 30.715480
location_point = Point(longitude, latitude)
radius = 5
shops = Location.objects.filter(
geo_location__distance_lt=(location_point, Distance(km=radius)))
results = serializers.serialize('json', shops)
data = json.loads(results)
x = [shop.geo_location.x for shop in shops]
y = [shop.geo_location.y for shop in shops]
mapbox_access_token = 'pk.eyJ1Ijoia2F1c2hhbDE3NyIsImEiOiJjazJlbDZseHUwNjNhM2xwdGgxeWZjNXNxIn0.nuPmPOZP5jRSy6LP4XP3gg'
print(x[0])
location = []
for i in range(len(x)):
g = geocoder.reverse_geocode(y[i], x[i])
location1 = g[0]['formatted'].split(',')
print(location1[0])
location.append(location1[0])
print(location)
return JsonResponse({'longitude':longitude,'latitude':latitude,\
'mapbox_access_token': mapbox_access_token,"x":x,'y':y,\
'shops':data,'location':location})
def to_python(self, value):
if value in self.empty_values:
return None
try:
obj = json.loads(value)
except JSONDecodeError:
raise DjangoValidationError(
self.default_error_messages["invalid_json"],
code="invalid_json")
if set(obj) != {"max_distance", "coordinates"}:
raise DjangoValidationError(
self.default_error_messages["invalid_fields"],
code="invalid_fields")
max_distance = obj["max_distance"]
coordinates = obj["coordinates"]
try:
max_distance = float(max_distance)
except ValueError:
raise DjangoValidationError(
self.default_error_messages["invalid_max_distance"],
code="invalid_max_distance",
)
if not check_coordinates(coordinates):
raise DjangoValidationError(
self.default_error_messages["invalid_coordinates"],
code="invalid_coordinates",
)
return Point(*coordinates), Distance(m=max_distance)
def radial_search(request):
"""View used to search by objects within a specif circular area.
This view receives parameters from GET request and returns a html page
containing the result.
Request params:
center: the center coordinate of the circle.
radius: the circle radius.
"""
center = Point(*[float(i) for i in request.GET['center'].split(',')])
radius = Distance(m=float(request.GET['radius']))
distance_query = (Q(points__distance_lte=(center, radius))
| Q(lines__distance_lte=(center, radius))
| Q(polys__distance_lte=(center, radius)))
objs = _fetch_geo_objects(distance_query, 100)
d = {}
if 'communities' in request.GET:
d['Community'] = objs['Community']
if 'needs' in request.GET:
need_categories = request.GET['need_categories'].split(',')
d['Need'] = []
for n in objs['Need']:
if [c for c in n.categories.all() if str(c.id) in need_categories]:
d['Need'].append(n)
if 'organizations' in request.GET:
d['Organization'] = objs['Organization']
if 'resources' in request.GET:
d['Resource'] = objs['Resource']
return d
def handle(self, *args, **options):
print 'start'
# Burning.objects.all().delete()
# o = Radiation.objects.get(pk=939)
# b = Burning()
# b.gridcode = o.gridcode
# b.day = 1
# b.time = 1
# b.geom = o.geom
# b.save()
b = Burning.objects.get(pk=939)
b.burning = 1
b.day = 1
b.time = 1
b.save()
###################DISTANCE########################
from django.contrib.gis.measure import Distance
from django.contrib.gis.geos import *
#from django.contrib.gis.geos import GEOSGeometry
lon = 148.869028
lat = -35.581528
DISTANCE_LIMIT_METERS = 5000
input_point = Point(lon, lat, srid=4326)
#input_point.transform(900913)
#for r in Radiation.objects.filter(geom__dwithin=(input_point , D(km=DISTANCE_LIMIT_METERS))):
dist = Distance(m=5000)
#dist = 5000
#import pdb; pdb.set_trace()
pnt = fromstr('POINT(-35.581528 148.869028)', srid=4326)
def convert_values(self, value, field, connection):
"""
Using the same routines that Oracle does we can convert our
extra selection objects into Geometry and Distance objects.
TODO: Make converted objects 'lazy' for less overhead.
"""
if connection.ops.oracle:
# Running through Oracle's first.
value = super(GeoQuery,
self).convert_values(value, field or GeomField(),
connection)
if value is None:
# Output from spatial function is NULL (e.g., called
# function on a geometry field with NULL value).
pass
elif isinstance(field, DistanceField):
# Using the field's distance attribute, can instantiate
# `Distance` with the right context.
value = Distance(**{field.distance_att: value})
elif isinstance(field, AreaField):
value = Area(**{field.area_att: value})
elif isinstance(field, (GeomField, GeometryField)) and value:
value = Geometry(value)
elif field is not None:
return super(GeoQuery,
self).convert_values(value, field, connection)
return value
def _get_distance(self):
from django.contrib.gis.measure import Distance
if self._distance is None:
# We didn't get it from the backend & we haven't tried calculating
# it yet. Check if geopy is available to do it the "slow" way
# (even though slow meant 100 distance calculations in 0.004 seconds
# in my testing).
if geopy_distance is None:
raise SpatialError(
"The backend doesn't have 'DISTANCE_AVAILABLE' enabled & the 'geopy' library could not be imported, so distance information is not available."
)
if not self._point_of_origin:
raise SpatialError("The original point is not available.")
if not hasattr(self, self._point_of_origin["field"]):
raise SpatialError(
"The field '%s' was not included in search results, so the distance could not be calculated."
% self._point_of_origin["field"])
po_lng, po_lat = self._point_of_origin["point"].coords
location_field = getattr(self, self._point_of_origin["field"])
if location_field is None:
return None
lf_lng, lf_lat = location_field.coords
self._distance = Distance(
km=geopy_distance.distance((po_lat, po_lng), (lf_lat,
lf_lng)).km)
# We've either already calculated it or the backend returned it, so
# let's use that.
return self._distance
def to_internal_value(self, data):
try:
params = {"{}".format(self.units): data}
data = Distance(**params)
except (TypeError, ValueError):
self.fail('invalid')
return data
def get_queryset(self):
#split params by which it applies to
mappoint_params = {}
for (param, result) in self.request.query_params.items():
if param in ['max_lat','min_lat','max_lon','min_lon','dataset','tags','tag','state','zipcode']:
mappoint_params[param] = result
#if none of this is specified, this is just too much
if len(mappoint_params) == 0:
raise ParseError('Too many results. Please restrict the mappoints.')
#now get the queryset
points = filter_request(mappoint_params,'mappoint')
distances = self.request.GET.getlist('distance')
unit = self.request.GET.getlist('unit')
if len(unit) > 1:
raise ParseError('No more than one unit may be specified.')
elif len(unit) == 0:
unit = 'mi'
elif unit[0] in ['m','km','mi']:
unit = unit[0]
else:
raise ParseError('Accepted units: m, km, mi')
if len(distances) == 0:
distances = [1,3,5]
unit = 'km'
else:
print distances
distances.sort()
kwargs = {unit:distances[-1]}
take_out = []
for point in points:
if point.id in take_out:
continue
take_out.extend(neighboring_points(point, points, Distance(**kwargs)).exclude(id=point.id).values_list('id',flat=True))
return points.exclude(id__in=take_out).distinct()
def length(self):
'''Determine the length of the route.'''
points = (waypoint.point
for waypoint in self.waypoint_set.orderby('time'))
meters = sum(
geopy_distance(a, b).meters for (a, b) in pairwise(points))
return Distance(m=meters)
def intersecting(cls, obj, distance=None, ordering=True, field='geom'):
"""
Small helper to filter all model instances by geometry intersection
"""
qs = cls.objects
if not obj.geom:
return qs.none()
if hasattr(qs, 'existing'):
qs = qs.existing()
if distance is None:
distance = obj.distance(cls)
if distance:
qs = qs.filter(**{'{}__dwithin'.format(field): (obj.geom, Distance(m=distance))})
else:
qs = qs.filter(**{'{}__intersects'.format(field): obj.geom})
if obj.geom.geom_type == 'LineString' and ordering:
# FIXME: move transform from DRF viewset to DRF itself and remove transform here
ewkt = obj.geom.transform(settings.SRID, clone=True).ewkt
qs = qs.extra(select={'ordering': 'ST_LineLocatePoint(ST_GeomFromEWKT(\'{ewkt}\'), ST_StartPoint((ST_Dump(ST_Intersection(ST_GeomFromEWKT(\'{ewkt}\'), geom))).geom))'.format(ewkt=ewkt)})
qs = qs.extra(order_by=['ordering'])
if obj.__class__ == cls:
# Prevent self intersection
qs = qs.exclude(pk=obj.pk)
return qs
def get_context_data(self, **kwargs):
"""Añade variables de contexto.
Incrementa en 1 anuncio.views.
Añade las siguientes variables de contexto:
- form (MessageCreateForm): Formulario de contacto.
- anuncios_related_list (queryset[Anuncio]): Anuncios del mismo tipo en la zona.
- favorite_list_by_owner (list): PKs con los favoritos del usuario
desde FavoriteListContextMixin.
"""
context = super().get_context_data(**kwargs)
anuncio = self.object
# Incrementar en 1 las vistas del anuncio.
# Omitir si es superuser o si el usuario es el owner.
if not self.request.user.is_superuser and anuncio.owner != self.request.user:
anuncio.views += 1
anuncio.save()
# Form de contacto.
form = MessageCreateForm(self.request.POST or None)
form.initial['anuncio'] = anuncio
form.initial['sender'] = self.request.user
form.initial['recipient'] = anuncio.owner
context['form'] = form
# Anuncios del mismo tipo en la misma zona.
distance = anuncios_settings.ANUNCIO_RELACIONADO_KMS
point = Point(anuncio.longitude, anuncio.latitude)
anuncios_related_list = Anuncio.get_model_class(
anuncio.category).objects.published(
type_anuncio=anuncio.type_anuncio,
point__distance_lt=(point, Distance(km=distance))
).exclude(pk=anuncio.pk).select_related('owner').prefetch_related(
'image_anuncio')[0:anuncios_settings.ANUNCIO_NUM_RELACIONADO]
context['anuncios_related_list'] = anuncios_related_list
return context
def get_near_instructors(self, lat, lon, distance=None, *args, **kwargs):
if not distance:
distance = 1
current_point = Point(lon, lat)
return self.filter(
lat_long_points__distance_lte=(current_point, Distance(km=distance)), **kwargs)
def filter_subway_stations(qs, values):
if values:
q = Q()
for subway_station in values:
if settings.MESTO_USE_GEODJANGO:
distance_filters = make_sphere_distance_filters(
'point', subway_station.point, Distance(m=1000))
else:
coords = (subway_station.coords_x, subway_station.coords_y)
distance_filters = make_coords_ranges_filters(
coords, Distance(m=1000))
q |= Q(**distance_filters)
qs = qs.filter(q)
return qs
def get_queryset(self):
longitude = float(self.request.query_params['longitude'])
latitude = float(self.request.query_params['latitude'])
radius = 10
point = Point(longitude, latitude)
return Party.objects.filter(
location__distance_lt=(point, Distance(km=radius)))
def nearby(self,request, *args, **kwargs):
location = request.GET['location'].split(',')
radius = request.GET['distance']
lat = location[0]
lng = location[1]
point = Point(float(lng), float(lat))
self.queryset = Climb.objects.filter(location__distance_lt=(point, Distance(km=radius)))
return super().list(request)
def filter(self, qs, value):
if value in EMPTY_VALUES:
return qs
lat, lng = value.split("#")
point = Point(float(lng), float(lat))
return qs.filter(store__point__distance_lt=(point, Distance(km=100)))
