def setUp(self):
self.public_agency_1 = Agency(name="Public 1",
city="San Francisco",
state="CA",
country="US",
location=db.GeoPt(
37.7749295, -122.4194155),
date_opened=datetime.fromtimestamp(0))
self.public_agency_1.put()
self.public_agency_2 = Agency(name="Public 2",
city="Seattle",
state="WA",
country="US",
location=db.GeoPt(
47.6062095, -122.3320708),
date_opened=datetime.fromtimestamp(0))
self.public_agency_2.put()
self.public_agency_3 = Agency(name="Public 3",
city="Kokomo",
state="IN",
country="US",
location=db.GeoPt(
40.486427, -86.1336033),
date_opened=datetime.fromtimestamp(0))
self.public_agency_3.put()
self.private_agency_1 = Agency(name="Private 1",
city="Washington",
state="DC",
country="US",
location=db.GeoPt(
38.8951118, -77.0363658))
self.private_agency_1.put()
self.private_agency_2 = Agency(name="Private 2",
city="Philadelphia",
state="PA",
country="US",
location=db.GeoPt(
39.952335, -75.163789))
self.private_agency_2.put()
self.private_agency_3 = Agency(name="Private 3",
city="Mars",
state="PA",
country="US",
location=db.GeoPt(
40.6958996, -80.0117254))
self.private_agency_3.put()
self.app_pub = TransitApp(title="app_pub",
supports_all_public_agencies=True)
self.app_pub.put()
self.app_p1 = TransitApp(title="app_p1")
self.app_p1.add_explicitly_supported_agency(self.private_agency_1)
self.app_p1.put()
self.app_p2_p3 = TransitApp(title="app_p2_p3")
self.app_p2_p3.add_explicitly_supported_agencies(
[self.private_agency_2, self.private_agency_3])
self.app_p2_p3.put()
self.app_pub_p1_p3 = TransitApp(title="app_pub_p1_p3",
supports_all_public_agencies=True)
self.app_pub_p1_p3.add_explicitly_supported_agencies(
[self.private_agency_1, self.private_agency_3])
self.app_pub_p1_p3.put()
self.app_pub_pub2_pub3_p1_p2 = TransitApp(
title="app_pub_pub2_pub3_p1_p2", supports_all_public_agencies=True)
self.app_pub_pub2_pub3_p1_p2.add_explicitly_supported_agencies([
self.public_agency_2, self.public_agency_3, self.private_agency_1,
self.private_agency_2
])
self.app_pub_pub2_pub3_p1_p2.put()
self.philadelphia = CityInfo(name="Philadelpha",
administrative_area="PA",
country_code="US",
latitude=39.952335,
longitude=-75.163789)
self.narberth = CityInfo(name="Narberth",
administrative_area="PA",
country_code="US",
latitude=40.0084456,
longitude=-75.26046)
self.berlin = CityInfo(name="Berlin",
administrative_area="Berlin",
country_code="DE",
latitude=52.5234051,
longitude=13.4113999)
self.grants_pass = CityInfo(name="Grants Pass",
administrative_area="OR",
country_code="US",
latitude=42.4390069,
longitude=-123.3283925)
self.portland = CityInfo(name="Portland",
administrative_area="OR",
country_code="US",
latitude=45.5234515,
longitude=-122.6762071)
self.app_for_philadelphia = TransitApp(title="app_for_philadelphia")
self.app_for_philadelphia.put()
self.app_for_philadelphia.add_explicitly_supported_city_info_immediate(
self.philadelphia)
self.app_for_narberth = TransitApp(title="app_for_narberth")
self.app_for_narberth.put()
self.app_for_narberth.add_explicitly_supported_city_info_immediate(
self.narberth)
self.app_for_entire_world = TransitApp(
title="app_for_entire_world",
explicitly_supports_the_entire_world=True)
self.app_for_entire_world.put()
self.app_for_us = TransitApp(title="app_for_us")
self.app_for_us.add_explicitly_supported_country("US")
self.app_for_us.put()
self.app_for_de = TransitApp(title="app_for_de")
self.app_for_de.add_explicitly_supported_country("DE")
self.app_for_de.put()
self.app_for_portland = TransitApp(title="app_for_portland")
self.app_for_portland.put()
self.app_for_portland.add_explicitly_supported_city_info_immediate(
self.portland)
def in_radius(self, reqHandler):
distance = geomath.distance(
db.GeoPt(self.loc),
db.GeoPt("%s,%s" % (reqHandler['lat'], reqHandler['lon'])))
radius = float(reqHandler['radius'])
return True if distance < radius else False
def post(self, relpath):
if relpath == 'live':
# Get first (and only) result.
live_data = models.LiveData.all().get()
if live_data is None:
live_data = models.LiveData()
live_data.gdl_page_url = self.request.get('gdl_page_url') or None
live_data.put()
return self.redirect('/database/live')
elif relpath == 'author':
try:
given_name = self.request.get('given_name')
family_name = self.request.get('family_name')
author = models.Author(
key_name=''.join([given_name, family_name]).lower(),
given_name=given_name,
family_name=family_name,
org=self.request.get('org'),
unit=self.request.get('unit'),
city=self.request.get('city'),
state=self.request.get('state'),
country=self.request.get('country'),
homepage=self.request.get('homepage') or None,
google_account=self.request.get('google_account') or None,
twitter_account=self.request.get('twitter_account')
or None,
email=self.request.get('email') or None,
lanyrd=self.request.get('lanyrd') == 'on')
lat = self.request.get('lat')
lon = self.request.get('lon')
if lat and lon:
author.geo_location = db.GeoPt(float(lat), float(lon))
author.put()
except db.Error:
pass
else:
self.redirect('/database/author')
elif relpath == 'resource':
author_key = models.Author.get_by_key_name(
self.request.get('author'))
author_key2 = models.Author.get_by_key_name(
self.request.get('second_author'))
if author_key.key() == author_key2.key():
author_key2 = None
tags = (self.request.get('tags') or '').split(',')
tags = [x.strip() for x in tags if x.strip()]
browser_support = [
x.lower()
for x in (self.request.get_all('browser_support') or [])
]
pub = datetime.datetime.strptime(
self.request.get('publication_date'), '%Y-%m-%d')
update_date = self.request.get('update_date') or None
tutorial = None
if self.request.get('post_id'):
tutorial = models.Resource.get_by_id(
int(self.request.get('post_id')))
# Updating existing resource.
if tutorial:
try:
#TODO: This is also hacky.
tutorial.title = self.request.get('title')
tutorial.description = self.request.get('description')
tutorial.author = author_key
tutorial.second_author = author_key2
tutorial.url = self.request.get('url') or None
tutorial.browser_support = browser_support
tutorial.update_date = datetime.date.today()
tutorial.publication_date = datetime.date(
pub.year, pub.month, pub.day)
tutorial.tags = tags
tutorial.draft = self.request.get('draft') == 'on'
tutorial.social_url = unicode(
self.request.get('social_url') or '')
except TypeError:
pass
else:
# Create new resource.
try:
tutorial = models.Resource(
title=self.request.get('title'),
description=self.request.get('description'),
author=author_key,
second_author=author_key2,
url=self.request.get('url') or None,
browser_support=browser_support,
update_date=datetime.date.today(),
publication_date=datetime.date(pub.year, pub.month,
pub.day),
tags=tags,
draft=self.request.get('draft') == 'on',
social_url=self.request.get('social_url') or None)
except TypeError:
pass
tutorial.put()
# TODO: Don't use flush_all. Use flush_all_async() or only purge tutorials.
# Once new entry is saved, flush memcache.
memcache.flush_all()
return self.redirect('/database/')
def _set_latitude(self, lat):
if not self.location:
self.location = db.GeoPt()
self.location.lat = lat
def _set_longitude(self, lon):
if not self.location:
self.location = db.GeoPt()
self.location.lon = lon
from geo.geomodel import GeoModel
class Neighborhood(db.Model):
name = db.StringProperty()
number_of_students = db.IntegerProperty()
percent_single_family = db.FloatProperty()
location = db.GeoPtProperty()
b_woods = Neighborhood()
b_woods.name = "b_woods"
b_woods.number_of_students = 120
b_woods.percent_single_family = 1.0
b_woods.location = db.GeoPt(33.969553, -84.159453)
b_woods.put()
card = Neighborhood()
card.name = "card"
card.number_of_students = 300
card.percent_single_family = 1.0
card.location = db.GeoPt(33.979392, -84.132407)
card.put()
class School(GeoModel):
name = db.StringProperty(required=True)
type = db.StringProperty(required=True, choices=set(["ES", "MS", "HS"]))
capacity = db.IntegerProperty()
#location = db.GeoPtProperty()
def post(self):
user = users.get_current_user()
if not user: # need to sign in
self.redirect('/?signin=True')
return
if bene_query.getCurrentUser(
).isConsumer: # consumers can't access this
self.redirect('/')
return
_producer = bene_query.getCurrentProducer()
if _producer == None: # no producer signed up, so ask to sign up
self.redirect('/')
return
if not _producer.verified: # if producer is not verified
self.redirect('/producerhome?%s' %
urllib.urlencode({'verify': True}))
return
ID = bene_util.sanitize(self.request.get('id'))
if not ID:
'''
TODO: If no ID sent, default to page with all locations?
'''
self.redirect('/')
return
_location = db.get(ID)
''' an error in getting the location will be redirected to exception handler'''
if _location.owner != user: # if not owner of location
self.redirect('/producerhome?%s' %
urllib.urlencode({'not_owner': True}))
return
_location.name = bene_util.sanitize(self.request.get('name'))
_location.address = bene_util.sanitize(self.request.get('address'))
_location.description = bene_util.sanitize(
self.request.get('description'))
_unique_save = _location.unique
_location.unique = bene_util.sanitize(self.request.get('unique'))
if bene_util.doesExactLocationExist(
_location
) and _unique_save != _location.unique: # if location with same unique exists
self.redirect('/editlocation?%s' %
(urllib.urlencode({
'id': ID,
'repeateditid': True
})))
return
if not _location.unique:
if bene_util.doesSimilarLocationExist(_location, key=True):
self.redirect('/editlocation?%s' %
(urllib.urlencode({
'id': ID,
'repeateditname': True
})))
return
_picture = self.request.get('picturedata')
_location.addPicture(_picture)
location = bene_util.sanitize(self.request.get('location'))
fields = location.split(',')
if len(fields) == 2:
try:
lat = float(fields[0])
lon = float(fields[1])
gp = db.GeoPt(lat, lon)
except ValueError:
gp = None
else:
gp = None
_location.location = gp
_location.put()
self.redirect('/viewlocation?%s' % urllib.urlencode({'id': ID}))
return
def get_place(self, request):
"""
Devuelve la informacion sobre un determinado sitio, incluyendo
la lista de sugerencias.
:param request: Parametros pasados a la peticion
:type request: :class:`GetPlaceRequest`
:returns: :class:`Place`
:raises: :class:`ApplicationError`
"""
from geouser.models import User
from geoalert.models_poi import Place as PlaceModel
from geovote.models import Vote
from geoalert.models import Suggestion as SuggestionModel
from geoalert.views import _get_city
from os import environ
from time import mktime
from google.appengine.ext import db
if request.id is None and request.google_places_reference is None:
raise ApplicationError("Unknow place")
user = User.objects.get_by_id(int(environ['user']))
def load_suggestions_async(suggestions):
suggestions_loaded = [s for s in suggestions]
from georemindme.funcs import prefetch_refprops
suggestions = prefetch_refprops(suggestions_loaded, SuggestionModel.user, SuggestionModel.poi)
suggestions_loaded = []
for a in suggestions:
t = Suggestion(
name = a.name,
description = a.description,
poi_lat = a.poi.location.lat,
poi_lon = a.poi.location.lon,
poi_id = a.poi.id,
google_places_reference = a.poi.google_places_reference,
modified = int(mktime(a.modified.utctimetuple())),
created = int(mktime(a.created.utctimetuple())),
username = a.user.username,
id = a.id,
)
suggestions_loaded.append(t)
return suggestions_loaded
if request.id is not None:
place = PlaceModel.objects.get_by_id(request.id)
else:
place = PlaceModel.objects.get_by_google_reference(request.google_places_reference)
if place is None:
raise ApplicationError("Unknow place")
query_id, suggestions_async = SuggestionModel.objects.get_by_place(place,
querier=user,
async = True
)
vote_counter = Vote.objects.get_vote_counter(place.key())
# es un lugar cargado desde google places
if place.google_places_reference is not None:
from mapsServices.places.GPRequest import GPRequest
try:
search = GPRequest().retrieve_reference(place.google_places_reference)
place.update(name=search['result']['name'],
address=search['result'].get('formatted_address'),
city=_get_city(search['result'].get('address_components')),
location=db.GeoPt(search['result']['geometry']['location']['lat'], search['result']['geometry']['location']['lng']),
google_places_reference=search['result']['reference'],
google_places_id=search['result']['id']
)
except:
pass
return Place(id = place.id,
name = place.name,
address = place.address,
city = place.city,
poi_lat = place.location.lat,
poi_lon = place.location.lon,
suggestions = Suggestions(query_id= query_id,
suggestions = load_suggestions_async(suggestions_async)
),
vote_counter = vote_counter,
google_places_reference=place.google_places_reference
)
def getGeoPoint(self, lat, lon):
return db.GeoPt(lat, lon)
def api_1_update(request):
result = {'success': False, 'message': 'Did not compute a result.'}
try:
request_time = datetime.datetime.utcnow()
request_guid = str(uuid.uuid4())
# Read data and basic sandity check
data = json.loads(request.raw_post_data.decode('utf8'))
if settings.RUNNING_APP_ENGINE_LOCAL_SERVER:
logging.info("\n\n*** REQUEST: \n%s\n" % data)
services = data.get('services', None)
if not services:
result[
'message'] = 'You must include service information in your post.'
return render_json(result, status=400)
# Handle location, if included
latitude = float(data.get('latitude', 0.0))
longitude = float(data.get('longitude', 0.0))
# Handle message, if any:
message = data.get('message', None)
if message is not None:
message = message.strip()
# Handle information for each service
user_services = []
for service in services:
user_service = UserService.get_or_insert_for_service_and_id(
service['service_type'], service['id_on_service'])
user_service.screen_name = service.get('screen_name',
user_service.screen_name)
user_service.display_name = service.get('display_name',
user_service.display_name)
user_service.profile_image_url = service.get(
'profile_image_url', user_service.profile_image_url)
user_service.large_profile_image_url = service.get(
'large_profile_image_url',
user_service.large_profile_image_url)
user_service.service_url = service.get('service_url',
user_service.service_url)
user_service.update_time = request_time
user_service.update_guid = request_guid
if latitude or longitude:
user_service.location = db.GeoPt(latitude, longitude)
if message and (user_service.message != message):
user_service.message = message
user_service.message_time = request_time
followers = service.get('followers', None)
if followers is not None:
user_service.set_followers(followers)
user_services.append(user_service)
# Attempt to save everything in the datastore... (failure will get caught)
db.put(user_services)
# Now cons up some updates, if they're desired...
want_updates = data.get('want_updates', False)
if want_updates:
updates = UserService.updates_for_user_services(
user_services, request_time)
else:
updates = []
except Exception, message:
result['message'] = 'Encountered an unexpected exception (%s %s)' % (
message, exception_string())
if not settings.RUNNING_APP_ENGINE_LOCAL_SERVER:
logging.info("\n\n*** REQUEST: \n%s\n" % data)
logging.info("\n\n*** RESPONSE: \n%s\n" % json.dumps(result))
logging.error("\n\n*** ERROR: \n%s\n" % result['message'])
return render_json(result, status=500)
logging.error("no value for 'checkins' in history: " + str(history))
userinfo.put()
return -1, 0
elif history['checkins']['items'] == None:
userinfo.put()
return 0, 0
history['checkins']['items'].reverse()
logging.debug('will process %d items' % (len(history['checkins']['items'])))
for checkin in history['checkins']['items']:
if 'venue' in checkin:
j_venue = checkin['venue']
if 'id' in j_venue:
uservenue = UserVenue.all().filter('user = '******'venue_guid = ', str(j_venue['id'])).get()
if not uservenue and 'location' in j_venue and 'lat' in j_venue['location'] and 'lng' in j_venue['location']:
userinfo.venue_count = userinfo.venue_count + 1
uservenue = UserVenue(parent=userinfo, location = db.GeoPt(j_venue['location']['lat'], j_venue['location']['lng']))
uservenue.venue_guid = str(j_venue['id'])
uservenue.update_location()
uservenue.user = userinfo.user
uservenue.checkin_guid_list = []
if uservenue: # if there's no uservenue by this point, then the venue was missing a location
uservenue.checkin_guid_list.append(str(checkin['id']))
userinfo.checkin_count += 1
def put_updated_uservenue_and_userinfo(uservenue_param, userinfo_param, num_added):
uservenue_param.put()
userinfo_param.put()
return num_added + 1
try:
num_added = db.run_in_transaction(put_updated_uservenue_and_userinfo, uservenue, userinfo, num_added)
except BadRequestError, err:
logging.warning("Database transaction error due to entity restrictions: %s" % err)
def lat_lon(s):
lat, lon = [float(v) for v in s.split(',')]
return db.GeoPt(lat, lon)