def delete(id):
entity = Route.get(id)
if (entity is None):
raise ValueError("Route does not exists")
else:
entity.active = False
Route.save(entity)
def account(request, email):
user = None
if email:
user = get_object_or_404(User, username=email)
if request.method == 'POST':
email = request.POST['email']
mobile_num = to_e164(request.POST['mobile_num'])
password = request.POST['password']
if not user:
if password == request.POST['confirm']:
user = User.objects.create(username=email, email=email)
user.set_password(password)
user.save()
UserProfile.objects.create(user=user).save()
send_confirmation_text(user, mobile_num)
user = auth.authenticate(username=user.username, password=password)
auth.login(request, user)
try:
route_json = request.session['route_json']
except IndexError:
pass
else:
r = Route(user=request.user, json=route_json, start_time=request.POST['start_time'])
r.save()
profile_data = {'mobile_num': mobile_num}
UserProfile.objects.filter(user=user).update(**profile_data)
return redirect('myroutes')
profile = user.get_profile() if user else None
return render(request, 'account.html', {'user': user, 'profile': profile})
def save(entity):
email = users.get_current_user().email()
if email is not None:
entity.created_by = email
if entity.key is None:
entity = Route.save(entity)
else:
current = Route.get(entity.key.urlsafe())
if current is not None:
current.company_key = entity.company_key
current.date = entity.date
current.driver_key = entity.driver_key
current.total_distance = entity.total_distance
current.total_time = entity.total_time
current.num_of_stops = entity.num_of_stops
current.status = entity.status
current.notes = entity.notes
current.active = entity.active
entity = Route.save(entity)
else:
raise ValueError("Route does not exists")
return entity
def account(request, email):
user = None
if email:
user = get_object_or_404(User, username=email)
if request.method == 'POST':
email = request.POST['email']
mobile_num = to_e164(request.POST['mobile_num'])
password = request.POST['password']
if not user:
if password == request.POST['confirm']:
user = User.objects.create(username=email, email=email)
user.set_password(password)
user.save()
UserProfile.objects.create(user=user).save()
send_confirmation_text(user, mobile_num)
user = auth.authenticate(username=user.username,
password=password)
auth.login(request, user)
try:
route_json = request.session['route_json']
except IndexError:
pass
else:
r = Route(user=request.user,
json=route_json,
start_time=request.POST['start_time'])
r.save()
profile_data = {'mobile_num': mobile_num}
UserProfile.objects.filter(user=user).update(**profile_data)
return redirect('myroutes')
profile = user.get_profile() if user else None
return render(request, 'account.html', {'user': user, 'profile': profile})
def create_route(payload):
body = request.get_json()
print(body)
new_route_name = body['route_name']
new_route_description = body['route_description']
new_route_difficulty = body['route_difficulty']
new_map_link = body['map_link']
new_length = body['length']
new_area = body['area']
try:
route = Route(
route_name=new_route_name,
area=new_area,
route_description=new_route_description,
route_difficulty=new_route_difficulty,
map_link=new_map_link,
length=new_length
)
print(route)
route.insert()
routes = list(map(Route.format,
Route.query.order_by(Route.route_name).all()))
'''current_questions = paginate_questions(request, selection)'''
return jsonify({
'success': True,
'routes': routes
})
except Exception as e:
print(e)
abort(422)
def get(self):
action = cgi.escape(self.request.get('action'))
if(action == 'load'):
routename = cgi.escape(self.request.get('routename'))
routes = Route.gql("WHERE name = :1", routename).fetch(1)
if(len(routes) == 0):
self.response.out.write("No route with name %s" % routename)
return
route = routes[0];
logging.info('Loading route %s', route.name)
vertices = []
for vertex in route.vertex_set:
vertices.append({'lat': vertex.lat, 'lng': vertex.lng})
logging.info('Loaded vertex with lat %s and lng %s', vertex.lat, vertex.lng)
result = {'vertices': vertices, 'routename': routename };
self.response.out.write(simplejson.dumps(result))
elif action == 'allnames':
result = []
for route in Route.all():
logging.info('Found route name %s', route.name);
result.append(route.name)
self.response.out.write(simplejson.dumps(result))
def update_values(self, values):
values["user_email"] = users.get_current_user().email().lower()
url_route_key = self.request.get('route')
if url_route_key != "":
route_key = ndb.Key(urlsafe=url_route_key)
# Next two lines are so that the recent routes list populates correctly.
route = route_key.get()
route.put()
stops_query = Stop.query(ancestor=route_key).order(
Stop.order_number).fetch()
stop1 = stops_query[0]
values["stop1"] = stop1.stop_name
if stop1.ordered:
values["stop1_checkbox"] = "on"
else:
values["stop1_checkbox"] = "off"
if (len(stops_query) > 1):
stop2 = stops_query[1]
values["stop2"] = stop2.stop_name
if stop2.ordered:
values["stop2_checkbox"] = "on"
else:
values["stop2_checkbox"] = "off"
if (len(stops_query) > 2):
stop3 = stops_query[2]
values["stop3"] = stop3.stop_name
if stop3.ordered:
values["stop3_checkbox"] = "on"
else:
values["stop3_checkbox"] = "off"
if (len(stops_query) > 3):
stop4 = stops_query[3]
values["stop4"] = stop4.stop_name
if stop4.ordered:
values["stop4_checkbox"] = "on"
else:
values["stop4_checkbox"] = "off"
if (len(stops_query) > 4):
stop5 = stops_query[4]
values["stop5"] = stop5.stop_name
if stop5.ordered:
values["stop5_checkbox"] = "on"
else:
values["stop5_checkbox"] = "off"
values["entity_key"] = url_route_key
else:
route_key = ""
recent_routes_query = Route.query(
ancestor=utils.get_parent_key_for_email(users.get_current_user(
).email())).order(-Route.last_touch_date_time)
values["recent_routes"] = recent_routes_query.fetch(5)
my_routes_query = Route.query(ancestor=utils.get_parent_key_for_email(
users.get_current_user().email())).filter(Route.type == 1).order(
Route.name)
values["my_routes"] = my_routes_query.fetch()
my_notifications_query = Notification.query(
ancestor=utils.get_parent_key_for_email(users.get_current_user(
).email())).filter(Notification.type != 2)
values["my_notifications"] = my_notifications_query.fetch()
def test_routeUpdate(self):
route = Route(1, 10, 'test', 'casual', 200, 20, 30, 1, 2)
db.session.add(route)
db.session.commit()
route.distance = 100
routeUpdate()
self.assertEqual(Route.query.filter_by(id=1).first().distance, 100)
def __init__(self, fallback_string, user, date=None):
self.user = user
# the date of this route, so we know which identifiers to look for
self.date = date
if not fallback_string: #return empty route
self.route = Route()
self.route.save()
return None
route = Route(fallback_string=fallback_string, p2p=False)
route.save()
is_p2p, routebases = self.make_routebases_from_fallback_string(route)
route.p2p = is_p2p
for routebase in routebases:
routebase.route = route
routebase.save()
route.easy_render()
self.route = route
def test_profile_page(self):
r = Route.from_string('SNTR SSBT')
response = self.client.get('/route-%s.html' % r.pk)
self.failUnlessEqual(response.status_code, 200)
r = Route.from_string('SNTR derp SSBT')
response = self.client.get('/route-%s.html' % r.pk)
self.failUnlessEqual(response.status_code, 200)
r = Route.from_string('SNTR @derp SSBT')
response = self.client.get('/route-%s.html' % r.pk)
self.failUnlessEqual(response.status_code, 200)
def insert_route(route_id, route_short_name, route_long_name):
"""
insert a new route
:param route_id: str, route id
:param route_short_name: str, short name for route
:param route_long_name: str, long name for route
:return:
"""
d = Route(route_id=route_id,
route_short_name=route_short_name,
route_long_name=route_long_name)
d.save()
def parse(self, url):
html = htmlutils.get_html(url)
print url
route = Route()
route.route = self.extract_route(html)
js_data = self.extract_js_data(html)
if js_data:
route.schedules = self.parse_js_data(js_data)
return route
def test_profile_page(self):
r = Route.from_string('SNTR SSBT')
response = self.client.get('/route-%s.html' % r.pk)
self.failUnlessEqual(response.status_code, 200)
r = Route.from_string('SNTR derp SSBT')
response = self.client.get('/route-%s.html' % r.pk)
self.failUnlessEqual(response.status_code, 200)
r = Route.from_string('SNTR @derp SSBT')
response = self.client.get('/route-%s.html' % r.pk)
self.failUnlessEqual(response.status_code, 200)
def bind(self, uuid):
"""Bind ``uuid`` resource to a service. """
services = Service.objects.annotate(
num_routes=Count('routes')).order_by('num_routes')
if not services:
raise NoServicesAvailable
service = services[0]
route = Route(uuid=uuid, service=service)
route.save()
return service
def bind(self, uuid):
"""Bind ``uuid`` resource to a service. """
services = Service.objects.annotate(
num_routes=Count('routes')).order_by('num_routes')
if not services:
raise NoServicesAvailable
service = services[0]
route = Route(uuid=uuid, service=service)
route.save()
return service
def route(request, id):
if request.method == 'POST':
if request.user.is_authenticated():
# store the route in the database for the user
r = Route(user=request.user, json=request.POST['route_json'])
r.save()
return redirect('myroutes')
else:
# store the route in session
# will store route in database for the user after
# we create the user
request.session['route_json'] = request.POST['route_json']
return redirect('account')
else:
return redirect('home')
def recommend(route_id):
"""vote any routes, but first check if the user is logged in, if not
redirect to the login page, and if the user already voted a specific route
an error message will that he/she already voted."""
route_id = route_id
user = User()
route = Route()
if 'username' in session:
if user.already_voted(session['username'], route_id):
flash('You already voted that route.')
return redirect('/bestroute')
route.vote_route(session['username'], route_id)
return redirect('/bestroute')
else:
return redirect('/login')
def route(request, id):
if request.method == 'POST':
if request.user.is_authenticated():
# store the route in the database for the user
r = Route(user=request.user, json=request.POST['route_json'])
r.save()
return redirect('myroutes')
else:
# store the route in session
# will store route in database for the user after
# we create the user
request.session['route_json'] = request.POST['route_json']
return redirect('account')
else:
return redirect('home')
def getRoutesAndSave(o, d):
data = json.load(open(data_prefix+'/data/%s_%s.json' % (o, d)))
for route_index, route in enumerate(data['routes']):
gpolyline = route['overview_polyline']['points']
linestring = google_lines.decode_line(gpolyline)
linestring.set_srid(canonical_projection)
linestring_dist = linestring.clone()
linestring_dist.transform(google_projection)
route_object = Route(geom=linestring, geom_dist=linestring_dist, \
summary=route['summary'], origin_taz=taz_lookup[o], \
destination_taz=taz_lookup[d], \
travel_time=compute_route_time(route), \
od_route_index=route_index, \
json_contents=json.dumps(route))
route_object.save()
def update_page_route(page):
"""
Add or update the page to the routing system.
"""
print '[ROUTER] update_page_route'
r = Route.query(Route.page_key == page.key).get() or Route()
r.searchable_page_names = []
r.all_lurls = page.get_all_lurls().values()
r.page_key = page.key
r.template_id = page.p_template_id
r.root_page = page.parent_section is None
for lang in page.get_languages():
r.set_page_name(page.get_name(lang), lang)
r.set_page_url(page.get_url(lang), lang)
r.put()
def getRoutesAndSave(o, d):
data = json.load(open(data_prefix+'/data/%s_%s.json' % (o, d)))
for route_index, route in enumerate(data['routes']):
gpolyline = route['overview_polyline']['points']
linestring = google_lines.decode_line(gpolyline)
linestring.set_srid(canonical_projection)
linestring_dist = linestring.clone()
linestring_dist.transform(google_projection)
route_object = Route(geom=linestring, geom_dist=linestring_dist, \
summary=route['summary'], origin_taz=taz_lookup[o], \
destination_taz=taz_lookup[d], \
travel_time=compute_route_time(route), \
od_route_index=route_index, \
json_contents=json.dumps(route))
route_object.save()
def remove_page_route(page_key):
"""
Remove a page from the routing system.
"""
# print 'router (remove_page_route) - DELETING ROUTE'
r = Route.query(Route.page_key == page_key).get()
r.key.delete()
def get(self, route_type=None, route_type_description=None):
base_query = Route.all().order("id")
if route_type:
base_query = base_query.filter('type =', int(route_type))
page = int(self.request.get('pagina', default_value=1))
routes = base_query.fetch(PAGESIZE + 1, offset=(page - 1) * PAGESIZE)
has_next = len(routes) > PAGESIZE
for route in routes:
if route.preview_image_url is None:
route.set_preview_image_url()
if route_type:
base_url = '/lista/%s/%s' % (route_type, route_type_description)
else:
base_url = '/'
template_values = {
'routes': routes,
'route_type': route_type_description,
'page': page,
'back_url': '%s?pagina=%d' % (base_url, page - 1) if page > 1 else None,
'next_url': '%s?pagina=%d' % (base_url, page + 1) if has_next else None,
}
path = os.path.join(os.path.dirname(__file__), 'templates/list.html')
self.response.out.write(template.render(path, template_values))
def search_routes(search_string, offset=0, limit=10):
base_query = Route.all()
words = get_words(search_string)
if search_string.endswith(' '):
#search routes that have all entire words
for word in words:
base_query = base_query.filter('searchable_words =', word)
elif len(words) == 0:
return []
elif len(words) == 1:
#search by routes that have word starting with text
word = words[0]
base_query = base_query.filter('searchable_words >=', word)
base_query = base_query.filter('searchable_words <', word[:-1] + chr(ord(word[-1]) + 1))
else:
#search by routes that have all first words complete and a word starting with last word
for word in words[:-1]:
base_query = base_query.filter('searchable_words =', word)
last_word = words[-1]
#need to order in memory (exploding indexes)
routes = [route for route in base_query.fetch(1000) if
any([word.startswith(last_word) for word in route.searchable_words])]
return routes[offset:limit]
return base_query.fetch(offset=offset, limit=limit)
async def post(self):
try:
args = RouteInputSchema().load(
escape.json_decode(self.request.body))
except ValidationError as e:
raise web.HTTPError(400, escape.json_encode(e.messages),
e.messages)
route_id = uuid.uuid4()
data = args.data
new_route = Route(
id=str(route_id),
origin=func.ST_GeomFromGeoJSON(escape.json_encode(data['origin'])),
origin_name=data['origin_name'],
destination=func.ST_GeomFromGeoJSON(
escape.json_encode(data['destination'])),
destination_name=data['destination_name'],
polyline=func.ST_GeomFromGeoJSON(escape.json_encode(data['polyline'])),
bounds=data.get('bounds'),
created=data.get('created') or datetime.utcnow()
)
self.db.add(new_route)
self.db.commit()
new_route_from_db = self._route_query().filter(
Route.id == str(route_id)).one()
schema = RouteOutputSchema()
output = schema.dumps(row_to_dict(new_route_from_db))
self.finish(output.data)
def save_route(code, sign, direction, main_to_sec, sec_to_main, type_route):
try:
route = Route.objects.get(code=code)
route.sign = sign
route.direction = direction
route.main_to_sec = main_to_sec
route.sec_to_main = sec_to_main
route.type_route = type_route
except Route.DoesNotExist:
route = Route(code=code,
sign=sign,
direction=direction,
main_to_sec=main_to_sec,
sec_to_main=sec_to_main,
type_route=type_route)
route.save()
return route
def test_route_distance(self):
r = Route.from_string('SNTR SSBT')
## 3 decimal places (forgive rounding errors)
s = "%3.3f"
real_val = 959.70030329462986
self.failUnlessEqual(s % r.max_start_all, s % real_val)
def create_route():
result = ''
error = ''
try:
route = Route(
request.json['routeId'],
request.json['busId'],
request.json['stopId']
)
route.save()
print('Added route: ', route)
result = 'Added route: {0}'.format(route.serialize())
except Exception as err:
print('Unexpected error:', err)
error = 'Error: {0}'.format(err)
return jsonify({'result': result, 'error': error})
def test_route_distance(self):
r = Route.from_string('SNTR SSBT')
## 3 decimal places (forgive rounding errors)
s = "%3.3f"
real_val = 959.70030329462986
self.failUnlessEqual(s % r.max_start_all, s % real_val)
def create_search_list():
def route_dict(route):
return {'url': route.get_absolute_url(),
'text': "%s - %s" % (route.short_name, route.long_name)}
routes = Route.all().fetch(2000)
data = [route_dict(route) for route in routes]
return simplejson.dumps(data)
def save_new_route(session, auth_type, route_view_method, route, route_name):
new_route = Route(
auth_type=auth_type,
route_view_method=route_view_method,
route=route,
route_name=route_name,
)
session.add(new_route)
def setUp(self):
self.maxDiff = None
db.session.remove()
db.drop_all()
db.create_all()
# adding users
user = User('adriangohjw', encrypt('password'), 'Adrian Goh')
db.session.add(user)
# add points
point_1 = Point(30.0, 40.0)
db.session.add(point_1)
point_2 = Point(50.0, 60.0)
db.session.add(point_2)
# add routes
route_1 = Route(
user_id=1,
distance=10,
polyline=
'evfGin%7CwR%5Cf@%60@Zh@Vb@JfBP%60CJtHd@LgBNiCF%7D@YCXBNe@PUr@i@p@c@lDsBj@c@DKJW@Yi@cA%7B@yBg@wAa@aAWaAg@qAoCaH%5BaAWs@k@OOEO?%5DDuEpBoInDo@TMVGREVRhBPbBH~AAzEAdD?XX@nAH~AJ@UAT_BKcCMHcGAcEUkC%5D%7DCEMPGbCaA%60MuFlDaB%60CuAdJuFnAy@r@a@pDuBtEuC%60CqARIZc@%5E%7B@Py@uB%7BH%7BF_TyAcFbAFbCJnD?@GtAWrCy@jAg@xAe@lDwA%7C@i@HSBe@wBuDNGVOfCsAtAs@%60@K@u@ES%7B@wAi@d@o@%5EXh@LLFFBH?ROZGHm@%5CiAh@e@IIKKQIWAW?WGEMGGGESA%5BFg@J%5DZe@TQNGH?%5CBJEMWMU%7B@b@%5BXSXQb@Kp@@l@Pz@j@jARZbAjBx@tAVL%5EFP?vAaAlD_CrCoBzAgAl@_@l@YvBaAbD%7BAnBs@VKlAS@GtAAfCDbAHtAP~Bh@%60A%5E%60Bz@zC~ApBqD%5EaAFo@EqGImG@%7DACWU_AY_AcBj@e@Ls@N_BTw@HaBDkAC%7DJ%5Dk%5Da@cBBa@DmAXeAXsCjAuG~CiCvAi@%60@q@v@U%5EgAxBU%60@SROLWLg@L_AFkA@g@AYCs@Oq@Ye@UcAYo@C%7D@?SZQXIXPtA%60@dBrGfVtBbHhAhEfDjMd@%7CAVv@tApFx@pCsAb@mA%60@wAr@_DpBu@Xs@d@kDpBy@h@aAl@%7DFzDsDhBSl@Kf@G%7C@jA%7CCz@%60CxAdDeBbA_FpCkBhAGHMPKXI~AUdE',
purpose='Casual',
calories=100,
ascent=1,
descent=2,
startPos_id=1,
endPos_id=2)
db.session.add(route_1)
route_2 = Route(
user_id=1,
distance=10,
polyline=
'evfGin%7CwR%5Cf@%60@Zh@Vb@JfBP%60CJtHd@LgBNiCF%7D@YCXBNe@PUr@i@p@c@lDsBj@c@DKJW@Yi@cA%7B@yBg@wAa@aAWaAg@qAoCaH%5BaAWs@k@OOEO?%5DDuEpBoInDo@TMVGREVRhBPbBH~AAzEAdD?XX@nAH~AJ@UAT_BKcCMHcGAcEUkC%5D%7DCEMPGbCaA%60MuFlDaB%60CuAdJuFnAy@r@a@pDuBtEuC%60CqARIZc@%5E%7B@Py@uB%7BH%7BF_TyAcFbAFbCJnD?@GtAWrCy@jAg@xAe@lDwA%7C@i@HSBe@wBuDNGVOfCsAtAs@%60@K@u@ES%7B@wAi@d@o@%5EXh@LLFFBH?ROZGHm@%5CiAh@e@IIKKQIWAW?WGEMGGGESA%5BFg@J%5DZe@TQNGH?%5CBJEMWMU%7B@b@%5BXSXQb@Kp@@l@Pz@j@jARZbAjBx@tAVL%5EFP?vAaAlD_CrCoBzAgAl@_@l@YvBaAbD%7BAnBs@VKlAS@GtAAfCDbAHtAP~Bh@%60A%5E%60Bz@zC~ApBqD%5EaAFo@EqGImG@%7DACWU_AY_AcBj@e@Ls@N_BTw@HaBDkAC%7DJ%5Dk%5Da@cBBa@DmAXeAXsCjAuG~CiCvAi@%60@q@v@U%5EgAxBU%60@SROLWLg@L_AFkA@g@AYCs@Oq@Ye@UcAYo@C%7D@?SZQXIXPtA%60@dBrGfVtBbHhAhEfDjMd@%7CAVv@tApFx@pCsAb@mA%60@wAr@_DpBu@Xs@d@kDpBy@h@aAl@%7DFzDsDhBSl@Kf@G%7C@jA%7CCz@%60CxAdDeBbA_FpCkBhAGHMPKXI~AUdE',
purpose='Casual',
calories=200,
ascent=1,
descent=2,
startPos_id=1,
endPos_id=2)
db.session.add(route_2)
db.session.commit()
def __init__(self, fallback_string, user, date=None):
self.user = user
# the date of this route, so we know which identifiers to look for
self.date = date
if not fallback_string: #return empty route
self.route = Route()
self.route.save()
return None
route = Route(fallback_string=fallback_string, p2p=False)
route.save()
is_p2p, routebases = self.make_routebases_from_fallback_string(route)
route.p2p = is_p2p
for routebase in routebases:
routebase.route = route
routebase.save()
route.easy_render()
self.route = route
def route_exists(url):
"""
Return whether a route exists or not.
"""
# print 'check route existence'
a = Route.query(Route.all_lurls == url).get()
# print 'route:'
# print a
return a is not None
def load_page_by_key(key_us):
"""
Load a page object starting from a key urlsafe string.
"""
# print 'load page by key'
key = ndb.Key(urlsafe=key_us)
r = Route.query(Route.page_key == key).get() or abort(404)
p = Template(r.template_id).load_page(r.page_key)
return p
def test_routeRead(self):
self.assertIsNone(routeRead(1))
route = Route(1, 10, 'test', 'casual', 200, 20, 30, 1, 2)
db.session.add(route)
db.session.commit()
self.assertEqual(routeRead(1).distance, 10)
def clean_route(self):
'''Translate number from autocomplete to object.
If not number, just create a new route with the text given as name
'''
data = self.cleaned_data['route']
try:
data = Route.objects.get(pk=data)
except ValueError: # not int, means name
if data: # Check that string i set, if not, leave it to exercise.save() to create autoroute
r = Route()
r.name = data
r.single_serving = True
r.save()
data = r
else:
return None
return data
def agencies_and_routes(self):
all_routes = {}
for agency in Agency.get_or_fetch().iteritems():
agency_tag = agency[0]
agency_model_dict = agency[1].to_dict()
agency_model_dict.setdefault("routes", []).append(Route.get_or_fetch(agency_tag))
all_routes[agency_tag] = agency_model_dict
return formatter.JSON(all_routes)
def get_stored_historic_score(origin,destination,startTime,endTime,sinceDate,beforeDate,alpha):
score = None
scores = None
calculatedScore = -1
today = datetime.now()
today = datetime(2015,05,07,15,00)
# If the route already exists, get from database, else save new instance.
route = Route.get_or_none(origin=origin,destination=destination)
if route is None:
route = Route(origin=origin,destination=destination)
route.save()
# If both extremes of the date range are not none, then the scores of
# the tweets from that time range are retrived.
if sinceDate is not None and beforeDate is not None:
scores = HistoricScore.get_scores_between_dates(route_id=route.id,
lower_timestamp=sinceDate,higher_timestamp=beforeDate)
else:
if sinceDate is None:
scores = HistoricScore.get_scores_until_date(route_id=route.id,timestamp=beforeDate)
if beforeDate is None:
scores = HistoricScore.get_scores_from_date(route_id=route.id,timestamp=sinceDate)
#If previous scores don't exist, then a score is calculated and saved to the database.
if scores is None or not scores:
# Verifies if a score was already calculated for the route with today's date.
score = HistoricScore.get_or_none(route_id=route.id,timestamp=today)
if score is None:
calculatedScore = get_score(related_tweets_time(origin, destination, startTime, endTime,
sinceDate, beforeDate))
score = HistoricScore(route_id=route.id,timestamp=today,score=calculatedScore)
score.save()
else:
calculatedScore = score.score
else:
calculatedScore = exponential_smoothing(scores,alpha)
return calculatedScore
def test_routeCreate(self):
self.assertEqual(len(Route.query.all()), 0)
route = Route(1, 10, 'test', 'casual', 200, 20, 30, 1, 2)
# record successfully created
self.assertTrue(routeCreate(route))
self.assertEqual(len(Route.query.all()), 1)
def weak_load_page_by_url(url):
"""
Load a page object starting from an url string.
"""
# print 'load page by url'
r = Route.query(Route.all_lurls == url).get()
# print r.key.urlsafe()
if r is None:
return r
p = Template(r.template_id).load_page(r.page_key)
return p
def weak_load_page_by_key(key_us):
"""
Load a page object starting from a key urlsafe string.
Return None if page not found.
"""
# print 'weak load page by key'
key = ndb.Key(urlsafe=key_us)
r = Route.query(Route.page_key == key).get()
if r is None:
return r
return Template(r.template_id).load_page(r.page_key)
def test_routeDelete(self):
route = Route(1, 10, 'test', 'casual', 200, 20, 30, 1, 2)
db.session.add(route)
db.session.commit()
self.assertEqual(len(Route.query.all()), 1)
routeDelete(1)
self.assertEqual(len(Route.query.all()), 0)
def get(self):
from util import slugify
def absolute_url(route):
return 'http://www.toape.com.br/%s/%s' % (route.id, slugify(route.long_name))
routes = Route.all().fetch(2000)
urls = ['http://www.toape.com.br']
urls += [absolute_url(route) for route in routes]
self.response.headers['Content-Type'] = "text/plain"
self.response.out.write('\n'.join(urls))
def request(port, path, body):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try:
sock.connect((HOST, port))
except:
print("ERR: Unable to connect to", port)
exit()
data = Route(path, body)
data = encrypt(data.serialize())
status = sock.sendall(data)
if status == None:
response = sock.recv(1024)
response = decrypt(response)
response = json.loads(response)
return response
else:
print("Could not send the request")
exit()
def load_routes():
session = Session()
routes = parse_routes()
rx = []
for r in routes:
rx.append(Route(r['rid'], r['name'], r['description'], r['color']))
session.add_all(rx)
session.commit()
def post(self):
if(self.request.get('action') == 'save'):
routename = self.request.get('name')
routes = Route.gql("WHERE name = :1", routename).fetch(1)
if len(routes) > 0:
self.response.out.write('Route %s already exists.' % routename)
return
json_route = simplejson.loads(self.request.get('route'))
logging.info('JSON route = %s', json_route)
vertices = [latLng.split(',') for latLng in json_route]
route = Route()
route.name = routename
route.put()
logging.info('Inserted route with name %s and id %s', route.name, route.key())
for index in range(0, len(vertices)):
vertex = Vertex()
vertex.lat = float(str(vertices[index][0]))
vertex.lng = float(str(vertices[index][1]))
vertex.route = route
vertex.put()
logging.info('Inserted vertex %s, %s on route %s with id %s', vertex.lat, vertex.lng, vertex.route.name, vertex.key())
self.response.out.write('Success')
def post(self):
message = xmpp.Message(self.request.POST)
if message.body == "routes":
r = Route.get_or_fetch("mbta")
message.reply(", ".join(r.keys()))
elif message.body == "@home":
e = Estimation.get_or_fetch("mbta", "747", "747_0_var0", "1807")
message.reply(formatter.JSON(e))
elif message.body == "@office":
e = Estimation.get_or_fetch("mbta", "747", "747_0_var1", "2231_1")
message.reply(formatter.JSON(e))
else:
message.reply("...")
def get(self, route_id=None, description=None):
route = Route.get_by_key_name(unquote(route_id))
if route:
trips = route.trip_set.fetch(1000)
trip_id = self.request.get('trip') or trips[0].id
trip = None
for trip_loop in trips:
if trip_loop.id == trip_id:
trip = trip_loop
break
if trip is None:
trip = trips[0]
similars = Trip.get_by_key_name(trip.similars)
template_values = {'route': route,
'trip': trip,
'trips': trips,
'similars': similars }
path = os.path.join(os.path.dirname(__file__), 'templates/route.html')
self.response.out.write(template.render(path, template_values))
else:
#Old urls used trip id. If this is the case, redirect
trip_id = route_id
trip = Trips.all().filter("trip_id =", unquote(trip_id)).get()
if trip:
route = Route.get_by_key_name(trip.route_id)
if route:
self.redirect(route.get_absolute_url(), permanent=True)
return
#Not found
self.error(404)
self.response.out.write('404 - Pagina nao encontrada')
def route_profile(request, r):
from django.contrib.auth.models import User
from airport.models import Location
from logbook.models import Flight
from models import RouteBase
from plane.models import Plane
from django.db.models import Sum
try:
route = Route.objects.filter(simple_rendered__iexact=r)[0]
rbs = RouteBase.objects\
.filter(route=route)\
.order_by('sequence')
except:
route = None
rbs = None
if not route:
from django.http import Http404
raise Http404
users = Route.get_profiles(r, 'simple_rendered')
t_flights = Flight.objects\
.filter(route__simple_rendered__iexact=r)\
.count()
types = Plane.objects\
.exclude(type="")\
.filter(flight__route__simple_rendered__iexact=r)\
.values_list('type', flat=True)\
.order_by()\
.distinct()
tailnumbers = Plane.objects\
.exclude(tailnumber="")\
.filter(flight__route__simple_rendered__iexact=r)\
.values_list('tailnumber', flat=True)\
.order_by('tailnumber')\
.distinct()
return locals()
def save_route(route_xml, api_call):
def save_directions(route_xml, route_obj, api_call):
directions = route_xml.findall('direction')
for direction in directions:
d = Direction.get_or_create(db.session,
tag = direction.get('tag'),
title = direction.get('title'),
name = direction.get('name'),
route_id = route_obj.id,
api_call_id = api_call.id)
def save_stops(route_xml, route_obj, api_call):
stops = route_xml.findall('stop')
for stop in stops:
s = Stop.get_or_create(db.session,
title = stop.get('title'),
lat = float(stop.get('lat')),
lon = float(stop.get('lon')),
stop_id = stop.get('stopId'),
api_call_id = api_call.id)
db.session.flush()
rs = RouteStop.get_or_create(db.session,
route_id = route_obj.id,
stop_id = s.id,
stop_tag = stop.get('tag'))
r = Route.get_or_create(db.session,
tag = route_xml.get('tag'),
title = route_xml.get('title'),
color = route_xml.get('color'),
opposite_color = route_xml.get('oppositeColor'),
lat_min = float(route_xml.get('latMin')),
lat_max = float(route_xml.get('latMax')),
lon_min = float(route_xml.get('lonMin')),
lon_max = float(route_xml.get('lonMax')),
agency_id = agency.id,
api_call = api_call)
db.session.flush()
save_directions(route_xml, r, api_call)
save_stops(route_xml, r, api_call)
db.session.flush()
return r
def routes(self, agency_tag):
return formatter.JSON(Route.get_or_fetch(agency_tag))
def route(self, agency_tag, route_tag):
return formatter.JSON(Route.properties(agency_tag, route_tag))
class MakeRoute(object):
"""
creates a route object from a string. The constructor takes a user
instance because it needs to know which "namespace" to use for
looking up custom places.
"""
def __init__(self, fallback_string, user, date=None):
self.user = user
# the date of this route, so we know which identifiers to look for
self.date = date
if not fallback_string: #return empty route
self.route = Route()
self.route.save()
return None
route = Route(fallback_string=fallback_string, p2p=False)
route.save()
is_p2p, routebases = self.make_routebases_from_fallback_string(route)
route.p2p = is_p2p
for routebase in routebases:
routebase.route = route
routebase.save()
route.easy_render()
self.route = route
def get_route(self):
return self.route
###########################################################
###########################################################
def normalize(self, string):
"""
removes all cruf away from the route string, returns only the
alpha numeric characters with clean seperators
"""
import re
string = string.upper()
string = string.replace("LOCAL", " ")
string = string.replace(" TO ", " ")
return re.sub(r'[^A-Z0-9!@]+', ' ', string).strip()
###########################################################
###########################################################
def find_navaid(self, ident, i, last_rb=None):
"""
Searches the database for the navaid object according to ident.
if it finds a match, creates and returns a routebase object
"""
if last_rb:
navaid = Location.objects.filter(loc_class=2, identifier=ident)
#if more than 1 navaids come up,
if navaid.count() > 1:
#run another query to find the nearest
last_point = last_rb.location
navaid = navaid.distance(last_point.location)\
.order_by('distance')[0]
elif navaid.count() == 0:
navaid = None
else:
navaid = navaid[0]
else:
# no previous routebases,
# dont other with the extra queries trying to find the nearest
# based on the last
try:
navaid = Location.objects.filter(loc_class=2,
identifier=ident)[0]
except IndexError:
navaid = None
if navaid:
return RouteBase(location=navaid, sequence=i)
else:
# wasn't a navaid, maybe it was an airport that they flew over?
return self.find_airport(ident, i)
return None
###########################################################################
def find_custom(self, ident, i, force=False):
"""
Tries to find the custom point, if it can't find one, and
force = True, it adds it to the user's custom list.
"""
ident = ident[:8]
if force:
cu,cr = Location.objects.get_or_create(user=self.user,
loc_class=3,
identifier=ident)
else:
try:
cu = Location.objects.filter(loc_class=3,
user=self.user,
identifier=ident)[0]
except IndexError:
cu = None
if cu:
return RouteBase(location=cu, sequence=i)
else:
return None
###########################################################################
def find_airport(self, ident, i):
"""
i = sequence of the airport in the route
ident = identifier, always uppercase
Uses the search_airport method to find the airport, then returns it as
a routebase
"""
def swap(ident):
"Swaps zero's and o's"
new = ident.replace('O', '&').replace('0', '$')
return new.replace('&', '0').replace('$', 'O')
if ident == '':
return None
numeric = re.search(r'[0-9]', ident)
date = self.date
retry = False
airport = self.search_airport(ident, date)
if not airport and len(ident) == 3 and not numeric:
# if the ident is 3 letters and no hit, try again with an added 'K'
retry = True
ident = "K" + ident
elif not airport and len(ident) == 4 and ident.startswith('K') and \
numeric:
# if the ident is 4 letters and starts with a 'K it's
# possible that the user has erroneously put it there, remove it
retry = True
ident = ident[1:]
if not airport and retry:
#try again with fixed identifier
airport = self.search_airport(ident, date)
if not airport and ('O' in ident or '0' in ident) and not ident.startswith('K'):
ident = swap(ident)
airport = self.search_airport(ident, date)
if airport:
return RouteBase(location=airport, sequence=i)
def search_airport(self, ident, date):
hi = HistoricalIdent.objects.filter(identifier=ident)
ex = Location.goon(loc_class=1, identifier=ident)
valid_hi = None
invalid_hi = None
airport_ident = None
airport = None
if hi.count() > 0:
try:
valid_hi = hi.get(start__lte=date, end__gte=date)
invalid_hi = None
except HistoricalIdent.DoesNotExist:
valid_hi = None
invalid_hi = hi.latest('end')
elif ex:
return ex
##############
if invalid_hi and not valid_hi and not ex:
#we dont have anything but an expired HI, just use it
return invalid_hi.current_location
elif invalid_hi and not valid_hi and ex:
# an ex trumps an invalid HI
return ex
elif valid_hi:
# we have a valid HI, use it no matter what!
return valid_hi.current_location
elif not valid_hi and not invalid_hi and not ex:
#we have nothing :(
return None
else:
assert False, "Some weird corner case"
def make_routebases_from_fallback_string(self, route):
"""
Returns a list of RouteBase objects according to the fallback_string,
basically hard_render()
"""
fbs = self.normalize(route.fallback_string)
points = fbs.split() # 'MER / VGA - mer' -> ['MER', 'VGA', 'MER']
unknown = False
p2p = []
routebases = []
for i, ident in enumerate(points):
if "@" in ident: # "@" means we didn't land
land = False
else:
land = True
if "!" in ident: # "!" means it's a custom place
custom = True
else:
custom = False
#replace all the control characters now that we know their purpose
ident = ident.replace('!','').replace('@','')
if not land and not custom: # must be a navaid
# is this the first routebase? if so don't try to guess which
# navaid is closest to the previous point
first_rb = len(routebases) == 0
if not first_rb and not routebases[i-1].unknown:
routebase = self.find_navaid(ident, i, last_rb=routebases[i-1])
else:
routebase = self.find_navaid(ident, i)
elif custom:
# force=True means if it can't find the 'custom', then make it
routebase = self.find_custom(ident, i, force=True)
else: #must be an airport
routebase = self.find_airport(ident, i)
if not routebase:
# if the airport can't be found, see if theres a 'custom'
# by the same identifier
routebase = self.find_custom(ident, i, force=False)
#######################################################################
# no routebase? must be unknown
if not routebase:
routebase = RouteBase(unknown=ident, sequence=i)
routebase.land = land
routebases.append(routebase)
if land:
loc = routebase.location or ident
p2p.append(loc)
return len(set(p2p)) > 1, routebases