def __add_search(self, product_name):
user_id = self.__get_user_id()
search = Search(parent=Search.default_parent_key(user_id),
product_name=product_name
)
user = users.get_current_user()
if user:
search.author = user
search.put()
def post(self):
#Get search term and sites from webform plus request ID
term = str(self.request.get('term'))
sites = str(self.request.get('sites'))
request_id = os.environ.get('REQUEST_LOG_ID')
thinktanks = str(self.request.get('thinktanks'))
media = str(self.request.get('media'))
univ_other = str(self.request.get('univ_other'))
explainers = str(self.request.get('explainers'))
if not sites:
sites = ''
#If checkboxes are checked, add sources to 'sites' list
if thinktanks and len(sites) > 0:
sites = sites + "," + sources_thinktanks
elif thinktanks:
sites = sites + sources_thinktanks
if media and len(sites) > 0:
sites = sites + "," + sources_topmedia
elif media:
sites = sites + sources_topmedia
if univ_other and len(sites) > 0:
sites = sites + "," + sources_univ_other
elif univ_other:
sites = sites + sources_univ_other
if explainers and len(sites) > 0:
sites = sites + "," + sources_explainers
elif explainers:
sites = sites + sources_explainers
#Save search info in db
search = Search(request_id=request_id,search_term=term,sites=sites)
s = search.put()
s = s.get()
search_id = str(s.key.id())
#Pass search info to BackgroundHandler
task = taskqueue.add(url='/background',
params={'search_id': search_id,'sites':sites,
'term':term})
#Send user to waiting page while background task is completed
results_path = "results/" + search_id
template_variables = {'term' : term, 'path' : results_path }
template = jinja_env.get_template('jumbotron_narrow_waiting.html')
self.response.write(template.render(template_variables))
def delete_search():
"""ajax call deleting search when route fails to load from google"""
search_id = request.form.get('search_id')
message = Search.delete_entry(search_id)
answer = {"message": message}
return jsonify(answer)
def get_points():
"""ajax call querying location"""
latitude = float(request.args.get("latitude"))
longitude = float(request.args.get("longitude"))
elevation = float(request.args.get("elevation"))
min_height = int(request.args.get("min_height"))
max_time = int(request.args.get("max_time"))
travel_mode = request.args.get("travel_mode")
user_id = session.get('user_id', None)
print latitude, longitude, elevation, min_height, max_time, travel_mode, user_id
result = Search.new_search(latitude, longitude, user_id, min_height,
max_time, travel_mode, elevation)
point = result["point"]
session.setdefault("history", []).append(result["id"])
if elevation > min_height:
message = "You're already at a safe location! If you want to climb even higher follow the route"
else:
message = "Hurry to safety! tik tok tik tok..."
answer = {
"point_elevation": int(point.elevation),
"latitude": point.latitude,
"longitude": point.longitude,
"elevation": int(elevation),
"travel_mode": travel_mode,
"max_time": max_time,
"message": message,
"search_id": result["id"]
}
print answer
return jsonify(answer)
def generate_yelp():
"""Return top-rated Yelp search result and create search object in database."""
mood = request.form.get('mood')
adjective = request.form.get('adjective')
alter_ego = request.form.get('alter_ego')
location = request.form.get('location')
start = geolocator.geocode(request.form.get('location'))
start_lat = start.latitude
start_lng = start.longitude
event = request.form.get('event')
city = request.form.get('city')
phone = request.form.get('phone')
biz = yelp_random_pick(event, city)
end_lat = biz.location.coordinate.latitude
end_lng = biz.location.coordinate.longitude
distance = vincenty((start_lat, start_lng), (end_lat, end_lng)).miles
sesh['user']['phone'] = phone
user = User.query.filter(User.email == sesh['user'].get('email')).first()
user_id = user.id
if user.phone == None:
user.phone = phone
db.session.commit()
search = Search(
user_id=user_id,
mood=mood,
adjective=adjective,
alter_ego=alter_ego,
event=event,
location=location,
start_lat=start_lat,
start_lng=start_lng,
destination=biz.name,
end_lat=end_lat,
end_lng=end_lng,
mileage=distance,
)
db.session.add(search)
db.session.commit()
return render_template(
'yelp_result.html',
biz=biz,
review=biz.snippet_text.replace('\n', ' '),
pic=sesh['user'].get('img_url'),
first_name=sesh['user'].get('first_name'),
location=location,
start_lat=start_lat,
start_lng=start_lng,
end_lat=end_lat,
end_lng=end_lng,
)
def get_history():
"""ajax call querying search history for person"""
response = {'history': []}
try:
user_id = session["user_id"]
history = User.get_history(user_id)
except:
try:
searches = session["history"]
history = Search.get_data(searches)
except:
history = None
if history:
for search in history:
thing = {
"start_lat": search.a.latitude,
"start_lng": search.a.longitude,
"start_ele": int(search.a.elevation),
"end_lat": search.p.latitude,
"end_lng": search.p.longitude,
"end_ele": int(search.p.elevation),
"min_ele": search.min_ele,
"max_time": search.max_time,
"travel_mode": search.travel_mode,
"search_id": search.search_id
}
response['history'].append(thing)
return jsonify(response)
def save_searches():
"""Saves search criteria by the user"""
user_name = request.form["name"]
# user_name = session["user_name"]
session_user = User.query.filter_by(user_name=user_name).first()
user_id = session_user.user_id
city = request.form["city"]
state = request.form["state"]
radius = int(request.form["radius"])
curr_lat = float(request.form["curr-lat"])
curr_long = float(request.form["curr-long"])
search_query = Search.query.filter_by(user_id=user_id, city=city, state=state,
lat_value=curr_lat,
long_value=curr_long,
radius=radius).count()
if curr_lat == 0.0:
# Check if the search is already saved by the user or not
if search_query == 0:
new_search = Search(user_id=user_id, city=city, state=state,
lat_value=curr_lat, long_value=curr_long,
radius=radius, searched_at=datetime.datetime.utcnow())
db.session.add(new_search)
db.session.commit()
return redirect("/user-profile/%s" % user_name)
def procurar():
global Search_Results, Search_word
Search_Results = Search.procurar(Last_search, request.form['SearchItem'])
Search_word = request.form['SearchItem']
return view.procurar(Search_Results)
def search():
results = []
city = ""
if request.method == 'POST':
city = request.form['city']
results = [
r for r in Search().find(json.loads('{"city": "' + city + '"}'))
]
return render_template('search.html', forecasts=results, city=city)
def create_search(user_id, created_at, query):
"""Create a new search"""
search = Search(user_id=user_id, created_at=created_at, query=query)
db.session.add(search)
db.session.commit()
return search
def store_search(search_phrase, document_id):
""" Store search information into the database """
search = Search(search_phrase=search_phrase, document_id=document_id)
db.session.add(search)
db.session.commit()
return search.search_id
def update_search_history():
"""ajax call updating search with distance and duration info"""
duration = request.form.get('duration')
distance = request.form.get('distance')
search_id = request.form.get('search_id')
success = Search.add_travel_data(search_id, duration, distance)
answer = {"message": success}
return jsonify(answer)
def create_search(num_search=20, price_range=None):
"""creata a search."""
uuid_num = uuid.uuid4()
search = Search(uuid=uuid_num,
num_search=num_search,
price_range=price_range)
db.session.add(search)
db.session.commit()
return search
def example_data():
"""Sample test data for database."""
user_1 = User(email="*****@*****.**", password="******")
search_1 = Search(search_term="testestest")
outlet_1 = Outlet(outlet_name='Best News',
outlet_popularity=10,
outlet_bias='Right-Center')
user_search_1 = User_Search(user_id=1, search_id=1)
db.session.add_all([user_1, search_1, outlet_1])
db.session.commit()
def save_search_to_db(user_id, search_term, location):
"""Saves searches to DB based on user_id."""
timestamp = datetime.now()
new_search = Search(user_id=user_id,
timestamp=timestamp,
search_term=search_term,
search_location=location)
db.session.add(new_search)
db.session.commit()
def get(self):
(url, url_linktext) = get_login_url_and_text(self.request.uri)
search_query = Search.query().order(-Search.date)
search_query = search_query.fetch(10)
template_values = {
'searches': search_query,
'url': url,
'url_linktext': url_linktext,
}
self.response.write(render_template('storage.html', **template_values))
def save_search():
save_type = request.form.get('save_type')
save_data = request.form.get('save_data')
address_url = request.form.get('save_url')
searches_url = request.form.get('searches_url')
# Parsing the unicode into a dictionary.
save_data = ast.literal_eval(save_data)
if session.get('user_id'):
if save_type == 'search':
search = Search(user_id=session.get('user_id'),
zipcode=save_data.get('zipcode'),
city=save_data.get('city'),
state=save_data.get('state'),
trans_type=save_data.get('trans_type'),
max_no_bed=save_data.get('max_no_bed'),
min_no_bed=save_data.get('min_no_bed'),
min_no_bath=save_data.get('min_no_bath'),
max_no_bath=save_data.get('max_no_bath'),
price_from=save_data.get('price_from'),
price_to=save_data.get('price_to'),
trans_date_from=save_data.get('trans_date_from'),
trans_date_to=save_data.get('trans_date_to'),
property_type=save_data.get('property_type'),
saved_date=datetime.datetime.now(),
saved_by_user=True,
search_url=searches_url)
db.session.add(search)
db.session.commit()
if save_type == 'address':
save_data = request.form.get('save_data')
save_data = ast.literal_eval(save_data)
# print save_data
_property = Property(user_id=session.get('user_id'),
property_id=save_data.get('property_id'),
address=save_data.get('address'),
latitude=float(save_data.get('latitude')),
longitude=float(save_data.get('longitude')),
no_of_beds=int(save_data.get('no_of_room')),
no_of_baths=float(
save_data.get('no_of_bath')),
saved_date=datetime.datetime.now(),
saved_by_user=True,
prop_url=address_url)
db.session.add(_property)
db.session.commit()
return jsonify({'Result': save_data})
def get(self):
key = self.get_argument('key', '').strip()
pageId = int(self.get_argument('page', '1'))
if len(key) == 0:
results = Article.all(self.db)
else:
results = Search.all(self.db, key)
p = Paginator(results, 5)
page = p.page(pageId)
isAdmin = self.isAdmin()
label_list = Label.group(self.db)
self.render('search.html', articles=page.object_list, label_list=label_list,
isAdmin=isAdmin, page=page, home_title=options.home_title,
user=options.user, photo=options.photo)
def cabinet():
if not check_creadentials():
return redirect('/')
login = request.cookies.get('login')
if request.method == 'POST':
city, weather, day, night, official = request.form[
'city'], request.form['weather'], request.form[
'day'], request.form['night'], int(
request.form.get('official', 0))
db.execute_sql(
'insert into forecasts VALUES(NULL, "{}", "{}", "{}", "{}", "{}", "{}")'
.format(login, city, weather, day, night, official))
Search().add(city, weather, day, night, str(official))
cursor = db.execute_sql(
'select * from forecasts where author="{}"'.format(login))
return render_template('cabinet.html',
forecasts=[row for row in cursor.fetchall()])
def _create_search(self):
user = User.query.filter_by(first_name='Jane').first()
search = Search(user_id=user.id,
mood='anxious',
adjective='epic',
alter_ego='TSwift',
event='eat',
location='San Francisco',
start_lat=37,
start_lng=-122,
destination='Ferry Building',
end_lat=37,
end_lng=-122,
mileage=5,
uber_request=True)
db.session.add(search)
db.session.commit()
def store_trips():
"""Add each trip search to the DB."""
user_id = session.get('username', 0)
search = Search(user_id=user_id)
db.session.add(search)
db.session.flush()
trip1 = json.loads(request.form['trip1'])
trip2 = json.loads(request.form['trip2'])
trips = [trip1, trip2]
for trip in trips:
trip = Trip(city_id=trip['cityId'],
search_id=search.search_id,
avg_temp=trip['weather'],
wow_factor=trip['wow'],
michelin_stars=trip['stars'],
airfare=trip['airfare'])
db.session.add(trip)
db.session.commit()
return 'success'
def get_search():
"""Process search request, renders user results of their request. """
user_id = session.get("user_id")
traveler1_name = request.form["traveler1_name"]
traveler2_name = request.form["traveler2_name"]
traveler1_origin = request.form["traveler1_origin"]
traveler2_origin = request.form["traveler2_origin"]
traveler1_max_price = int(request.form["traveler1_max_price"])
traveler2_max_price = int(request.form["traveler2_max_price"])
departure_date = request.form["departure_date"]
return_date = request.form["return_date"]
destination = request.form["destination"]
session['destination'] = destination
t1 = Flight.query.filter_by(
outbound_city_origin=cities[traveler1_origin],
inbound_city_origin=cities[destination]).filter(
Flight.total_fare <= traveler1_max_price).first()
alt1 = None
if not t1:
alt1 = Flight.query.filter_by(
outbound_city_origin=cities[traveler1_origin],
inbound_city_origin=cities[destination]).first()
t2 = Flight.query.filter_by(
outbound_city_origin=cities[traveler2_origin],
inbound_city_origin=cities[destination]).filter(
Flight.total_fare <= traveler2_max_price).first()
alt2 = None
if not t2:
alt2 = Flight.query.filter_by(
outbound_city_origin=cities[traveler2_origin],
inbound_city_origin=cities[destination]).first()
print "t1 and t2 are", t1, t2
t1_remainder = traveler1_max_price - 1223
# else:
# t1_remainder = traveler1_max_price - alt1.total_fare
t2_remainder = traveler1_max_price - 1890
# else:
# t2_remainder = traveler1_max_price - alt2.total_fare
total_remainder = t1_remainder + t2_remainder
if user_id:
search_request = Search(user_id=user_id,
traveler1_name=traveler1_name,
traveler2_name=traveler2_name,
traveler1_origin=traveler1_origin,
traveler2_origin=traveler2_origin,
traveler1_max_price=traveler1_max_price,
traveler2_max_price=traveler2_max_price,
departure_date=departure_date,
return_date=return_date,
destination=destination)
db.session.add(search_request)
db.session.commit()
search_request_id = Search.query.filter_by(
user_id=user_id,
traveler1_name=traveler1_name,
traveler2_name=traveler2_name,
traveler1_origin=traveler1_origin,
traveler2_origin=traveler2_origin,
traveler1_max_price=traveler1_max_price,
traveler2_max_price=traveler2_max_price,
departure_date=departure_date,
return_date=return_date,
destination=destination).first()
print "&" * 100
print search_request_id
print search_request_id.user_id
print "&" * 100
airbnb_link = create_airbnb_url(cities[destination], departure_date,
return_date, total_remainder)
return render_template("search_results.html",
search_request=search_request,
search_request_id=search_request_id,
t1=t1,
t2=t2,
alt1=alt1,
alt2=alt2,
destination=destination,
traveler1_name=traveler1_name,
traveler2_name=traveler2_name,
airbnb_link=airbnb_link)
airbnb_link = create_airbnb_url(cities[destination], departure_date,
return_date, total_remainder)
print "airbnb link is", airbnb_link, "################"
return render_template("search_results.html",
t1=t1,
t2=t2,
alt1=alt1,
alt2=alt2,
destination=destination,
traveler1_name=traveler1_name,
traveler2_name=traveler2_name,
airbnb_link=airbnb_link)
def __get_user_last_searches(self, size):
user_id = self.__get_user_id()
search_query = Search.query(
ancestor=Search.default_parent_key(user_id)).order(-Search.date)
return search_query.fetch(size)
def search_for_term():
""" Update visual to show new coverage for search term """
fav_search = request.form.get('favorite-search')
keyword = request.form.get('keyword')
add_or_remove = request.form.get('arterm')
if add_or_remove == 'favorite':
user = User.query.get(session['user_id'])
for search in user.searches:
if keyword == search.search_term:
flash('You cannot favorite the same term twice!')
return redirect('/searchbykeyword')
else:
term = Search.query.filter(Search.search_term == keyword).first()
if term is None:
term = Search(search_term=keyword)
user.searches.append(term)
db.session.commit()
# flash('Your term is now added to favorites!')
elif add_or_remove == 'delete':
user = User.query.get(session['user_id'])
term = Search.query.filter(Search.search_term == fav_search).one()
user.searches.remove(term)
db.session.commit()
# flash('Your term is deleted')
return 'deleted'
elif keyword == None or keyword == '' or keyword == []:
keyword = fav_search
r = requests.get(('https://newsapi.org/v2/top-headlines?language=en&q={}&sortBy=relevancy'+
'&apiKey=b033aef85417499e96a7cd8148b0e7d4').format(keyword))
top_search_json = r.json()
# print top_search_json
# print top_trending_json
top_searches = top_search_json['articles']
# # print top_articles
# if top_searches == None:
# print
for i in range(len(top_searches)):
source_name = top_searches[i].get('source')['name']
# pull objects from newsflashdb
data = Outlet.query.filter(Outlet.outlet_name == source_name).first()
# add popularity and bias into json
if data is not None:
top_searches[i]['popularity'] = data.outlet_popularity
top_searches[i]['bias'] = data.outlet_bias
else:
top_searches[i]['popularity'] = False
top_searches[i]['bias'] = False
return jsonify(top_searches)
