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 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 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 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 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 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 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