def test_adjacent(self):
cell = geocell.compute(geotypes.Point(37, -122), 14)
box = geocell.compute_box(cell)
# adjacency tests using bounding boxes
self.assertEquals(box.north,
geocell.compute_box(geocell.adjacent(cell, (0, 1))).south)
self.assertEquals(box.south,
geocell.compute_box(geocell.adjacent(cell, (0, -1))).north)
self.assertEquals(box.east,
geocell.compute_box(geocell.adjacent(cell, (1, 0))).west)
self.assertEquals(box.west,
geocell.compute_box(geocell.adjacent(cell, (-1, 0))).east)
self.assertEquals(8, len(geocell.all_adjacents(cell)))
# also test collinearity
self.assertTrue(
geocell.collinear(cell, geocell.adjacent(cell, (0, 1)), True))
self.assertFalse(
geocell.collinear(cell, geocell.adjacent(cell, (0, 1)), False))
self.assertTrue(
geocell.collinear(cell, geocell.adjacent(cell, (1, 0)), False))
self.assertFalse(
geocell.collinear(cell, geocell.adjacent(cell, (1, 0)), True))
def test_adjacent(self):
cell = geocell.compute(geotypes.Point(37, -122), 14)
box = geocell.compute_box(cell)
# adjacency tests using bounding boxes
self.assertEquals(box.north,
geocell.compute_box(geocell.adjacent(cell, (0, 1))).south)
self.assertEquals(box.south,
geocell.compute_box(geocell.adjacent(cell, (0, -1))).north)
self.assertEquals(box.east,
geocell.compute_box(geocell.adjacent(cell, (1, 0))).west)
self.assertEquals(box.west,
geocell.compute_box(geocell.adjacent(cell, (-1, 0))).east)
self.assertEquals(8, len(geocell.all_adjacents(cell)))
# also test collinearity
self.assertTrue(
geocell.collinear(cell, geocell.adjacent(cell, (0, 1)), True))
self.assertFalse(
geocell.collinear(cell, geocell.adjacent(cell, (0, 1)), False))
self.assertTrue(
geocell.collinear(cell, geocell.adjacent(cell, (1, 0)), False))
self.assertFalse(
geocell.collinear(cell, geocell.adjacent(cell, (1, 0)), True))
def get(self):
user = users.get_current_user()
r = FlowerbedAdd()
if self.request.get('lat') and self.request.get('lon'):
#TODO: check if flowerbed is far enough from others
#TODO: check if flowerbed is close enough to user
lat = int(self.request.get('lat')) / 1000000.0
lon = int(self.request.get('lon')) / 1000000.0
gamer_key = Key.from_path(kloombaDb.Gamer.kind(), user.user_id())
gamer_hash = hashlib.md5(user.user_id() + SALT).hexdigest()
r.timestamp = int(time.time())
#get backpack
bp_beds = GqlQuery('SELECT * FROM Backpack WHERE ANCESTOR IS :1 AND name=:2', gamer_key, 'flowerbed').get()
if bp_beds.amount:
#lower backpack
bp_beds.amount -= 1
bp_beds.put()
#add flowerbed
point = GeoPt(lat, lon)
cell = geocell.compute(point, RULES['GEO_RESOLUTION'])
flowerbed = kloombaDb.Flowerbed(parent=Key.from_path(kloombaDb.Flowerbed.kind(), cell))
flowerbed.point = point
flowerbed.tile = cell
flowerbed.owner = user.user_id()
flowerbed.owner_public_id = gamer_hash
flowerbed.put()
#save to memcache
memcache.set(str(flowerbed.key()), flowerbed)
#add possession
possession = kloombaDb.Possession(parent=gamer_key)
possession.flowerbed = flowerbed
possession.put()
backpack = GqlQuery('SELECT * FROM Backpack WHERE ANCESTOR IS :1', gamer_key).run()
#set timestamps
r.flowerbed.timestamp = int(time.time())
r.backpack.timestamp = int(time.time())
#set flowerbed
r.flowerbed.id = str(flowerbed.key())
r.flowerbed.latitude = int(self.request.get('lat'))
r.flowerbed.longitude = int(self.request.get('lon'))
r.flowerbed.owner = gamer_hash
r.flowerbed.flowers = 0
#set backpack
for i in backpack:
bp = r.backpack.item.add()
bp.name = i.name
bp.amount = i.amount
if self.request.get('debug', False):
self.response.out.write(r)
else:
self.response.out.write(r.SerializeToString())
def test_compute(self):
# a valid geocell
cell = geocell.compute(geotypes.Point(37, -122), 14)
self.assertEqual(14, len(cell))
self.assertTrue(geocell.is_valid(cell))
self.assertTrue(geocell.contains_point(cell, geotypes.Point(37, -122)))
# a lower resolution cell should be a prefix to a higher resolution
# cell containing the same point
lowres_cell = geocell.compute(geotypes.Point(37, -122), 8)
self.assertTrue(cell.startswith(lowres_cell))
self.assertTrue(geocell.contains_point(lowres_cell,
geotypes.Point(37, -122)))
# an invalid geocell
cell = geocell.compute(geotypes.Point(0, 0), 0)
self.assertEqual(0, len(cell))
self.assertFalse(geocell.is_valid(cell))
def test_compute(self):
# a valid geocell
cell = geocell.compute(geotypes.Point(37, -122), 14)
self.assertEqual(14, len(cell))
self.assertTrue(geocell.is_valid(cell))
self.assertTrue(geocell.contains_point(cell, geotypes.Point(37, -122)))
# a lower resolution cell should be a prefix to a higher resolution
# cell containing the same point
lowres_cell = geocell.compute(geotypes.Point(37, -122), 8)
self.assertTrue(cell.startswith(lowres_cell))
self.assertTrue(geocell.contains_point(lowres_cell,
geotypes.Point(37, -122)))
# an invalid geocell
cell = geocell.compute(geotypes.Point(0, 0), 0)
self.assertEqual(0, len(cell))
self.assertFalse(geocell.is_valid(cell))
def test_interpolation(self):
cell = geocell.compute(geotypes.Point(37, -122), 14)
sw_adjacent = geocell.adjacent(cell, (-1, -1))
sw_adjacent2 = geocell.adjacent(sw_adjacent, (-1, -1))
# interpolate between a cell and south-west adjacent, should return
# 4 total cells
self.assertEquals(4, len(geocell.interpolate(cell, sw_adjacent)))
self.assertEquals(4, geocell.interpolation_count(cell, sw_adjacent))
# interpolate between a cell and the cell SW-adjacent twice over,
# should return 9 total cells
self.assertEquals(9, len(geocell.interpolate(cell, sw_adjacent2)))
self.assertEquals(9, geocell.interpolation_count(cell, sw_adjacent2))
def test_interpolation(self):
cell = geocell.compute(geotypes.Point(37, -122), 14)
sw_adjacent = geocell.adjacent(cell, (-1, -1))
sw_adjacent2 = geocell.adjacent(sw_adjacent, (-1, -1))
# interpolate between a cell and south-west adjacent, should return
# 4 total cells
self.assertEquals(4, len(geocell.interpolate(cell, sw_adjacent)))
self.assertEquals(4, geocell.interpolation_count(cell, sw_adjacent))
# interpolate between a cell and the cell SW-adjacent twice over,
# should return 9 total cells
self.assertEquals(9, len(geocell.interpolate(cell, sw_adjacent2)))
self.assertEquals(9, geocell.interpolation_count(cell, sw_adjacent2))
def update_property_index(self, pi):
pi.location = self.location
max_res_geocell, primos = geocell.compute(
self.location, geocell.MAX_GEOCELL_RESOLUTION, True)
tmp = [
max_res_geocell[:res]
for res in range(1, geocell.MAX_GEOCELL_RESOLUTION + 1)
]
pi.location_geocells = sorted(tmp + primos) + self.check_options_ex()
pi.price_sell_computed = self.price_sell_computed
pi.price_rent_computed = self.price_rent_computed
pi.area_indoor = self.area_indoor
pi.bedrooms = self.bedrooms
pi.rooms = self.rooms
pi.images_count = self.has_images()
pi.realestate = self.realestate
pi.property = self.key()
def get(self):
r = FlowerbedExplore()
user = users.get_current_user()
gamer_key = Key.from_path(kloombaDb.Gamer.kind(), user.user_id())
gamer = GqlQuery('SELECT * FROM Gamer WHERE ANCESTOR IS :1',
gamer_key).get()
if self.request.get('lat') and self.request.get('lon'):
r.timestamp = int(time.time())
lat = float(self.request.get('lat')) / 1000000
lon = float(self.request.get('lon')) / 1000000
gamer.point = GeoPt(lat, lon) #update user position
#take adjacent tiles
tiles = []
requests = []
tile = geocell.compute(GeoPt(lat, lon), RULES['GEO_RESOLUTION'])
tiles.append(tile)
tiles.extend(geocell.all_adjacents(tile))
kind = kloombaDb.Flowerbed.kind()
#prepare async requests
for i in tiles:
request = GqlQuery(
'SELECT * FROM Flowerbed WHERE ANCESTOR IS :1',
Key.from_path(kind, i)).run()
requests.append(request)
for i in requests:
for j in i:
fb = r.flowerbed.add()
fb.timestamp = int(time.mktime(j.timestamp.timetuple()))
fb.id = str(j.key())
fb.latitude = int(j.point.lat * 1000000)
fb.longitude = int(j.point.lon * 1000000)
fb.owner = j.owner_public_id
fb.flowers = j.flowers
gamer.put()
if self.request.get('debug', False):
self.response.out.write(r)
else:
self.response.out.write(r.SerializeToString())
def get(self):
r = FlowerbedExplore()
user = users.get_current_user()
gamer_key = Key.from_path(kloombaDb.Gamer.kind(), user.user_id())
gamer = GqlQuery('SELECT * FROM Gamer WHERE ANCESTOR IS :1', gamer_key).get()
if self.request.get('lat') and self.request.get('lon'):
r.timestamp = int(time.time())
lat = float(self.request.get('lat')) / 1000000
lon = float(self.request.get('lon')) / 1000000
gamer.point = GeoPt(lat, lon) #update user position
#take adjacent tiles
tiles = []
requests = []
tile = geocell.compute(GeoPt(lat, lon), RULES['GEO_RESOLUTION'])
tiles.append(tile)
tiles.extend(geocell.all_adjacents(tile))
kind = kloombaDb.Flowerbed.kind()
#prepare async requests
for i in tiles:
request = GqlQuery('SELECT * FROM Flowerbed WHERE ANCESTOR IS :1', Key.from_path(kind, i)).run()
requests.append(request)
for i in requests:
for j in i:
fb = r.flowerbed.add()
fb.timestamp = int(time.mktime(j.timestamp.timetuple()))
fb.id = str(j.key())
fb.latitude = int(j.point.lat * 1000000)
fb.longitude = int(j.point.lon * 1000000)
fb.owner = j.owner_public_id
fb.flowers = j.flowers
gamer.put()
if self.request.get('debug', False):
self.response.out.write(r)
else:
self.response.out.write(r.SerializeToString())
def test_compute_box(self):
cell = geocell.compute(geotypes.Point(37, -122), 14)
box = geocell.compute_box(cell)
self.assertTrue(box.south <= 37 and 37 <= box.north and
box.west <= -122 and -122 <= box.east)
import webapp2
import webapp2
def test_compute_box(self):
cell = geocell.compute(geotypes.Point(37, -122), 14)
box = geocell.compute_box(cell)
self.assertTrue(box.south <= 37 and 37 <= box.north and
box.west <= -122 and -122 <= box.east)
def get(self):
user = users.get_current_user()
r = FlowerbedAdd()
if self.request.get('lat') and self.request.get('lon'):
#TODO: check if flowerbed is far enough from others
#TODO: check if flowerbed is close enough to user
lat = int(self.request.get('lat')) / 1000000.0
lon = int(self.request.get('lon')) / 1000000.0
gamer_key = Key.from_path(kloombaDb.Gamer.kind(), user.user_id())
gamer_hash = hashlib.md5(user.user_id() + SALT).hexdigest()
r.timestamp = int(time.time())
#get backpack
bp_beds = GqlQuery(
'SELECT * FROM Backpack WHERE ANCESTOR IS :1 AND name=:2',
gamer_key, 'flowerbed').get()
if bp_beds.amount:
#lower backpack
bp_beds.amount -= 1
bp_beds.put()
#add flowerbed
point = GeoPt(lat, lon)
cell = geocell.compute(point, RULES['GEO_RESOLUTION'])
flowerbed = kloombaDb.Flowerbed(
parent=Key.from_path(kloombaDb.Flowerbed.kind(), cell))
flowerbed.point = point
flowerbed.tile = cell
flowerbed.owner = user.user_id()
flowerbed.owner_public_id = gamer_hash
flowerbed.put()
#save to memcache
memcache.set(str(flowerbed.key()), flowerbed)
#add possession
possession = kloombaDb.Possession(parent=gamer_key)
possession.flowerbed = flowerbed
possession.put()
backpack = GqlQuery(
'SELECT * FROM Backpack WHERE ANCESTOR IS :1',
gamer_key).run()
#set timestamps
r.flowerbed.timestamp = int(time.time())
r.backpack.timestamp = int(time.time())
#set flowerbed
r.flowerbed.id = str(flowerbed.key())
r.flowerbed.latitude = int(self.request.get('lat'))
r.flowerbed.longitude = int(self.request.get('lon'))
r.flowerbed.owner = gamer_hash
r.flowerbed.flowers = 0
#set backpack
for i in backpack:
bp = r.backpack.item.add()
bp.name = i.name
bp.amount = i.amount
if self.request.get('debug', False):
self.response.out.write(r)
else:
self.response.out.write(r.SerializeToString())
