def profile(request):
u = User.objects.get(username=request.session['user'])
wishlist = [Wish(u.username, i.item, i.store, i.count, i.metric) for i in Item.objects.filter(user=u)]
stores = [store for store in open(os.path.join(settings.BASE_DIR, "cost/shopping/stores.txt"),"r")]
users = User.objects.all().exclude(username=request.session['user'])
addsend = [a.address for a in PickupLocation.objects.filter(user=u)]
google_maps = GoogleMaps(api_key='AIzaSyC8hihi26xJqO77v4R2qJMii0cn6S2eW8w')
userwishlist = []
for user in users:
addrec = []
addr = PickupLocation.objects.filter(user=user)
for a in addr:
addrec.append(a.address)
items = google_maps.distance(addrec, addsend).all()
for item in items:
if item.distance.miles <= 10:
userwishlist.append(Wish(i.user, i.item, i.store) for i in Item.objects.filter(user=user))
break
userwishlist = [Wish(i.user, i.item, i.store, i.count, i.metric) for i in Item.objects.all().exclude(user=u)]
mywishlist = [Wish(i.receiver, i.item, i.store, i.count, i.metric) for i in UserItem.objects.filter(buyer=u)]
try:
locs = PickupLocation.objects.filter(user=u)
except:
locs = []
c = {'STATIC_URL':settings.STATIC_URL, 'user':request.session['user'], 'wishlist':wishlist, 'mywishlist':mywishlist, 'userwishlist':userwishlist, 'stores':stores, 'locs':locs, 'feedbackform':FeedbackForm()}
return render(request, "shopping_profile.html", c)
class DistanceMatrixTest(unittest.TestCase):
def setUp(self):
self.google_maps = GoogleMaps(api_key=TEST_API_KEY)
def test_distance_matrix(self):
origins = ['rybnik', 'oslo']
destinations = ['zagrzeb']
items = self.google_maps.distance(origins, destinations).all()
for item in items:
if item.origin == 'Rybnik, Poland':
self.assertEqual(item.destination, 'Zagreb, Croatia')
self.assertEqual(item.distance.kilometers, Decimal(713))
self.assertEqual(item.distance.meters, 713000)
self.assertEqual(item.distance.miles, 443.0368)
self.assertEqual(str(item.duration), '0d 7h 7m 47s')
if item.origin == 'Oslo, Norway':
self.assertEqual(item.destination, 'Zagreb, Croatia')
self.assertEqual(item.distance.kilometers, 2063)
self.assertEqual(item.distance.meters, 2063000)
self.assertEqual(item.distance.miles, 1281.8863)
self.assertEqual(str(item.duration), '0d 21h 18m 29s')
def test_distance_matrix_bicycling(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations,
const.MODE_BICYCLING).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertEqual(item.distance.kilometers, 1596)
self.assertEqual(item.distance.meters, 1596000)
self.assertEqual(item.distance.miles, 991.7065)
self.assertEqual(str(item.duration), '3d 11h 7m 25s')
def test_distance_matrix_walking(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations,
const.MODE_WALKING).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertEqual(item.distance.kilometers, 1380)
self.assertEqual(item.distance.meters, 1380000)
self.assertEqual(item.distance.miles, 857.4906)
self.assertEqual(str(item.duration), '10d 9h 32m 16s')
def test_distance_matrix_avoid_tolls(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins,
destinations,
avoid=const.AVOID_TOLLS).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertEqual(item.distance.kilometers, 1542)
self.assertEqual(item.distance.meters, 1542000)
self.assertEqual(item.distance.miles, 958.1525)
self.assertEqual(str(item.duration), '0d 16h 30m 40s')
def test_distance_matrix_avoid_highways(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins,
destinations,
avoid=const.AVOID_HIGHWAYS).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertEqual(item.distance.kilometers, 1491)
self.assertEqual(item.distance.meters, 1491000)
self.assertEqual(item.distance.miles, 926.4627)
self.assertEqual(str(item.duration), '1d 1h 36m 6s')
def test_distance_matrix_avoid_ferries(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins,
destinations,
avoid=const.AVOID_FERRIES).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertEqual(item.distance.kilometers, 1851)
self.assertEqual(item.distance.meters, 1851000)
self.assertEqual(item.distance.miles, 1150.1559)
self.assertEqual(str(item.duration), '0d 17h 35m 44s')
# -*- coding: utf-8 -*-
from geolocation.google_maps import GoogleMaps
from geolocation.distance_matrix import const
if __name__ == "__main__":
origins = ['rybnik', 'oslo']
destinations = ['zagrzeb']
google_maps = GoogleMaps(api_key='your_google_maps_key')
items = google_maps.distance(origins, destinations).all() # default mode parameter is const.MODE_DRIVING
for item in items:
print('origin: %s' % item.origin)
print('destination: %s' % item.destination)
print('km: %s' % item.distance.kilometers)
print('m: %s' % item.distance.meters)
print('miles: %s' % item.distance.miles)
print('duration: %s' % item.duration) # it returns str
print('duration datetime: %s' % item.duration.datetime) # it returns datetime
# you can also get items from duration
print('duration days: %s' % item.duration.days)
print('duration hours: %s' % item.duration.hours)
print('duration minutes: %s' % item.duration.minutes)
print('duration seconds: %s' % item.duration.seconds)
items = google_maps.distance(origins, destinations, const.MODE_BICYCLING).all()
for item in items:
print('origin: %s' % item.origin)
# -*- coding: utf-8 -*-
from geolocation.google_maps import GoogleMaps
from geolocation.distance_matrix import const
if __name__ == "__main__":
origins = ['rybnik', 'oslo']
destinations = ['zagrzeb']
google_maps = GoogleMaps(api_key='your_google_maps_key')
items = google_maps.distance(origins, destinations).all() # default mode parameter is const.MODE_DRIVING
for item in items:
print('origin: %s' % item.origin)
print('destination: %s' % item.destination)
print('km: %s' % item.distance.kilometers)
print('m: %s' % item.distance.meters)
print('miles: %s' % item.distance.miles)
print('duration: %s' % item.duration) # it returns str
print('duration datetime: %s' % item.duration.datetime) # it returns datetime
# you can also get items from duration
print('duration days: %s' % item.duration.days)
print('duration hours: %s' % item.duration.hours)
print('duration minutes: %s' % item.duration.minutes)
print('duration seconds: %s' % item.duration.seconds)
items = google_maps.distance(origins, destinations, const.MODE_BICYCLING).all()
for item in items:
print('origin: %s' % item.origin)
class DistanceMatrixTest(unittest.TestCase):
def setUp(self):
self.google_maps = GoogleMaps(api_key=TEST_API_KEY)
self.duration_regex = r'([0-9]*)d ([0-9]*)h ([0-9]*)m ([0-9]*)s'
self.delta_km = 25
self.delta_m = 25000
self.delta_miles = 25
def test_distance_matrix(self):
origins = ['rybnik', 'oslo']
destinations = ['zagrzeb']
items = self.google_maps.distance(origins, destinations).all()
for item in items:
if item.origin == 'Rybnik, Poland':
self.assertEqual(item.destination, 'Zagreb, Croatia')
self.assertAlmostEqual(float(709), item.distance.kilometers, delta=self.delta_km)
self.assertAlmostEqual(float(713000), item.distance.meters, delta=self.delta_m)
self.assertAlmostEqual(float(443.0368), item.distance.miles, delta=self.delta_miles)
self.assertRegexpMatches(str(item.duration), self.duration_regex)
if item.origin == 'Oslo, Norway':
self.assertEqual(item.destination, 'Zagreb, Croatia')
self.assertAlmostEqual(float(2063), item.distance.kilometers, delta=self.delta_km)
self.assertAlmostEqual(float(2063000), item.distance.meters, delta=self.delta_m)
self.assertAlmostEqual(float(1281.8863), item.distance.miles, delta=self.delta_miles)
self.assertRegexpMatches(str(item.duration), self.duration_regex)
def test_distance_matrix_bicycling(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations, const.MODE_BICYCLING).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertAlmostEqual(float(1596), item.distance.kilometers, delta=self.delta_km)
self.assertAlmostEqual(float(1596000), item.distance.meters, delta=self.delta_m)
self.assertAlmostEqual(float(991.7065), item.distance.miles, delta=self.delta_miles)
self.assertRegexpMatches(str(item.duration), self.duration_regex)
def test_distance_matrix_walking(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations, const.MODE_WALKING).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertAlmostEqual(float(1380), item.distance.kilometers, delta=self.delta_km)
self.assertAlmostEqual(float(1380000), item.distance.meters, delta=self.delta_m)
self.assertAlmostEqual(float(857.4906), item.distance.miles, delta=self.delta_miles)
self.assertRegexpMatches(str(item.duration), self.duration_regex)
def test_distance_matrix_avoid_tolls(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations, avoid=const.AVOID_TOLLS).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertAlmostEqual(float(1542), item.distance.kilometers, delta=self.delta_km)
self.assertAlmostEqual(float(1542000), item.distance.meters, delta=self.delta_m)
self.assertAlmostEqual(float(958.1525), item.distance.miles, delta=self.delta_miles)
self.assertRegexpMatches(str(item.duration), self.duration_regex)
def test_distance_matrix_avoid_highways(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations, avoid=const.AVOID_HIGHWAYS).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertAlmostEqual(float(1542), item.distance.kilometers, delta=self.delta_km)
self.assertAlmostEqual(float(1542000), item.distance.meters, delta=self.delta_m)
self.assertAlmostEqual(float(958.1525), item.distance.miles, delta=self.delta_miles)
self.assertRegexpMatches(str(item.duration), self.duration_regex)
def test_distance_matrix_avoid_ferries(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations, avoid=const.AVOID_FERRIES).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertAlmostEqual(float(1851), item.distance.kilometers, delta=self.delta_km)
self.assertAlmostEqual(float(1851000), item.distance.meters, delta=self.delta_m)
self.assertAlmostEqual(float(1150.1559), item.distance.miles, delta=self.delta_miles)
self.assertRegexpMatches(str(item.duration), self.duration_regex)
__author__ = 'liquidcable'
import time
import datetime
from geolocation.google_maps import GoogleMaps
from geolocation.distance_matrix import const
origins = ['30.519124,-97.793315']
destinations = ['30.2558053,-97.7391038']
google_maps = GoogleMaps(api_key='AIzaSyCnR7A11dEIwRHDhxOHpfmamptn3AGUNlo')
print ("-----------------------------------------------------------")
print ("Google Maps Distance - takes a new measurement every minute")
print ("Heath Holcomb | liquidcable.com | [email protected]")
print ("-----------------------------------------------------------")
items = google_maps.distance(origins, destinations).all()
for item in items:
print ('origin: %s' % item.origin)
print ('destination: %s' % item.destination)
print ('km: %s' % item.distance.kilometers)
print ('m: %s' % item.distance.meters)
print ('miles: %s' % item.distance.miles)
print ('duration: %s' % item.duration)
print ('duration datetime: %s' % item.duration.datetime)
for x in range(0,90):
print ("-----------------------------------------------------------")
time.sleep(600)
print ("time: " + time.strftime("%I:%M:%S"))
def search_radius(search_center, postalcodes, radius):
""" Finds zipcodes in the database that are within a search radius of a
location.
This uses the python library geolocation-python, which uses the
GoogleMaps API.
Takes in search center as a string, postalcodes as a list of tuples
(because that is the format returned from the database), and search
radius in miles as an integer. The function returns the list of
postal codes in the given list that are within the given radius.
"""
# Future versions: make a table in the database to store distance search
# results.
# For now store frequest searches in a dictionary to prevent eof error,
# likely from hitting Google Maps API too frequently within a given
# amount of time.
distances = {'94612': {'94109': 11.2468,
'94612': 0.0,
'94040': 45.4221,
'94115': 13.2973,
'95376': 53.1893,
'94043': 39.0842,
'10013': 2899.3124,
},
'94109': {'94109': 0.0,
'94612': 10.9361,
'94040': 38.9599,
'94115': 1.2427,
'95376': 62.137,
'10013': 2904.9047,
'94043': 37.2201,
},
}
# SQLite returns the distinct postal codes as a list of tuples. Convert this
# to a list of postal code strings.
postalcodes_in_db = []
for postalcode in postalcodes:
postalcodes_in_db.append(postalcode[0])
distinct_postalcodes = postalcodes_in_db
postalcodes_within_radius = []
if search_center in distances:
distinct_postalcodes = []
postalcodes_to_remove = []
for postalcode in postalcodes_in_db:
if postalcode in distances[search_center]:
if distances[search_center][postalcode] <= radius:
postalcodes_within_radius.append(postalcode)
# Always add postalcode to the list of postal codes to remove.
postalcodes_to_remove.append(postalcode)
# Check if there are still postal codes to check.
if len(postalcodes_in_db) > len(postalcodes_to_remove):
distinct_postalcodes = [postalcode for postalcode in postalcodes_in_db if postalcode not in postalcodes_to_remove]
# Use GoogleMaps API there are still things left in distinct_postalcodes
if distinct_postalcodes:
google_maps = GoogleMaps(api_key=os.environ['GOOGLE_API_KEY'])
# Put search center in a list because that is how the the geolocation
# distance module takes it in as a parameter
search_center = [search_center]
# Now we can calculate distances.
items = google_maps.distance(search_center, distinct_postalcodes).all()
# Items is list of distance matrix object thingies. Each has an origin,
# destination, and distance between the origin and destination.
# First we'll take out the matrix thingies within the search
# radius of the given search center.
matrixthingies = []
for item in items:
if (item.distance.miles <= radius):
matrixthingies.append(item)
# Now we pull out the user location info from the matrixthingies. This info
# has the city, state, zipcode and country.
destinations = []
for thingy in matrixthingies:
destinations.append(thingy.destination)
# Now we pull out the zipcode from the list of destinations.
for destination in destinations:
line = destination.split()
postalcode = line[-2].replace(",", "")
postalcodes_within_radius.append(postalcode)
return postalcodes_within_radius
class DistanceMatrixTest(unittest.TestCase):
def setUp(self):
self.google_maps = GoogleMaps(api_key=TEST_API_KEY)
def test_distance_matrix(self):
origins = ['rybnik', 'oslo']
destinations = ['zagrzeb']
items = self.google_maps.distance(origins, destinations).all()
for item in items:
if item.origin == 'Rybnik, Poland':
self.assertEqual(item.destination, 'Zagreb, Croatia')
self.assertEqual(item.distance.kilometers, Decimal(713))
self.assertEqual(item.distance.meters, 713000)
self.assertEqual(item.distance.miles, 443.0368)
self.assertEqual(str(item.duration), '0d 7h 7m 47s')
if item.origin == 'Oslo, Norway':
self.assertEqual(item.destination, 'Zagreb, Croatia')
self.assertEqual(item.distance.kilometers, 2063)
self.assertEqual(item.distance.meters, 2063000)
self.assertEqual(item.distance.miles, 1281.8863)
self.assertEqual(str(item.duration), '0d 21h 18m 29s')
def test_distance_matrix_bicycling(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations, const.MODE_BICYCLING).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertEqual(item.distance.kilometers, 1596)
self.assertEqual(item.distance.meters, 1596000)
self.assertEqual(item.distance.miles, 991.7065)
self.assertEqual(str(item.duration), '3d 11h 7m 25s')
def test_distance_matrix_walking(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations, const.MODE_WALKING).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertEqual(item.distance.kilometers, 1380)
self.assertEqual(item.distance.meters, 1380000)
self.assertEqual(item.distance.miles, 857.4906)
self.assertEqual(str(item.duration), '10d 9h 32m 16s')
def test_distance_matrix_avoid_tolls(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations, avoid=const.AVOID_TOLLS).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertEqual(item.distance.kilometers, 1542)
self.assertEqual(item.distance.meters, 1542000)
self.assertEqual(item.distance.miles, 958.1525)
self.assertEqual(str(item.duration), '0d 16h 30m 40s')
def test_distance_matrix_avoid_highways(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations, avoid=const.AVOID_HIGHWAYS).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertEqual(item.distance.kilometers, 1491)
self.assertEqual(item.distance.meters, 1491000)
self.assertEqual(item.distance.miles, 926.4627)
self.assertEqual(str(item.duration), '1d 1h 36m 6s')
def test_distance_matrix_avoid_ferries(self):
origins = ['rybnik']
destinations = ['oslo']
item = self.google_maps.distance(origins, destinations, avoid=const.AVOID_FERRIES).first()
self.assertEqual(item.origin, 'Rybnik, Poland')
self.assertEqual(item.destination, 'Oslo, Norway')
self.assertEqual(item.distance.kilometers, 1851)
self.assertEqual(item.distance.meters, 1851000)
self.assertEqual(item.distance.miles, 1150.1559)
self.assertEqual(str(item.duration), '0d 17h 35m 44s')
