def parse_restaurant(result_soup):
restaurant = Restaurant()
# name
name_soup = result_soup.find('a', class_='name')
if name_soup is not None:
restaurant.name = name_soup.text.strip()
# address
address1_soup = result_soup.find('strong')
if address1_soup is not None:
address_match = re.search('(.*) (\d{5})', address1_soup.text.strip())
if address_match:
restaurant.address = address_match.group(1)
restaurant.postcode = address_match.group(2)
address2_soup = result_soup.find('span', class_='address')
if address2_soup is not None:
restaurant.address += ' ' + address2_soup.text.strip()
# cuisines
cuisine_soup = result_soup.find('span', class_='tipo-label')
if cuisine_soup is not None:
restaurant.cuisines = [cuisine_soup.text.strip()]
return restaurant
def process_restaurant_registration():
"""Process restaurant registration."""
name = request.form.get("name")
email = request.form.get("email")
password = request.form.get("password")
street_address = request.form.get("street-address")
city = request.form.get("city")
state = request.form.get("state")
zipcode = request.form.get("zipcode")
if Restaurant.query.filter_by(email=email).first():
flash("An account with this email already exists.")
return redirect("/register")
new_restaurant = Restaurant(name=name,
email=email,
street_address=street_address,
city=city,
state=state,
zipcode=zipcode)
new_restaurant.set_password(password)
db.session.add(new_restaurant)
db.session.commit()
restaurant_id = new_restaurant.id
# Log in new restaurant.
session["restaurant_id"] = restaurant_id
flash(f"Successfully registered {name}.")
return redirect(f"/restaurant-dashboard/{restaurant_id}")
def load_restaurants():
"""Load restaurants from restaurants.txt into database."""
print("Restaurants")
# Read restaurants.txt file and insert data
for row in open("seed_data/restaurants.txt"):
row = row.rstrip()
id, name, street_address, city, state, zipcode, email, password = row.split(
"|")
restaurant = Restaurant(id=id,
name=name,
street_address=street_address,
city=city,
state=state,
zipcode=zipcode,
email=email)
restaurant.set_password(password)
# We need to add to the session or it won't ever be stored
db.session.add(restaurant)
# Once we're done, we should commit our work
db.session.commit()
def _parse_restaurant(self, restaurant_soup):
restaurant = Restaurant()
# ranking
ranking_soup = restaurant_soup.find('span', class_='indexed-biz-name')
if ranking_soup:
ranking_match = re.search('(\d+)\.', ranking_soup.text)
if ranking_match:
restaurant.ranking = ranking_match.group(1)
# name & link
link_soup = restaurant_soup.find('a', class_='biz-name')
if link_soup:
restaurant.url = self.base_url + link_soup['href']
restaurant_name_soup = link_soup.find('span')
if restaurant_name_soup:
restaurant.name = restaurant_name_soup.text
# reviews
reviews_soup = restaurant_soup.find('span', class_='review-count')
if reviews_soup:
reviews_match = re.search('(\d+)', reviews_soup.text)
if reviews_match:
restaurant.review_count = reviews_match.group(1)
# rating
rating_soup = restaurant_soup.find('i', class_='star-img')
if rating_soup:
rating_match = re.search('(\d(\.\d)?)', rating_soup['title'])
if rating_match:
restaurant.rating = rating_match.group(1)
# cuisines
cuisines_soup = restaurant_soup.find('span', 'category-str-list')
if cuisines_soup:
cuisine_soup_list = cuisines_soup.find_all('a')
restaurant.cuisines = []
for cuisine_soup in cuisine_soup_list:
restaurant.cuisines.append(cuisine_soup.text)
# address
address_soup = restaurant_soup.find('address')
if address_soup:
address_match = re.search('(.*)(\d{5})([\s\S]*)', address_soup.text.strip())
if address_match:
restaurant.address = '%s, %s' % (address_match.group(1), address_match.group(3))
restaurant.postcode = address_match.group(2)
# price
price_soup = restaurant_soup.find('span', class_='price-range')
if price_soup:
restaurant.price = price_soup.text
return restaurant
def load_restaurants():
"""Load restaurants into database from restaurant.txt file"""
print "Loading Restaurants"
#Delete all rows in table to reseed data every time this function is called
Restaurant.query.delete()
#Read the source file and insert data, use 'rU' so \r is read as line break
for line in open('seed/restaurants.csv', 'rU'):
line = line.rstrip()
name, opentable_id, eater, yelp, timeout, zagat, michelin, infatuation, lat, lng = line.split(
',')
if opentable_id == 'None':
opentable_id = None
#create restaurant object based on inputs from the line
restaurant = Restaurant(name=name,
opentable_id=opentable_id,
eater=eater,
yelp=yelp,
timeout=timeout,
zagat=zagat,
michelin=michelin,
infatuation=infatuation,
lat=lat,
lng=lng)
#add restaurant to the database
db.session.add(restaurant)
#commit work
db.session.commit()
def create_restaurant(latitude,
longitude,
name,
price=None,
location=None,
phone=None,
image=None,
yelp_id=None):
"""Create and return a new restaurant."""
restaurant = Restaurant.query.filter(
(Restaurant.yelp_id == yelp_id)).first()
if restaurant is not None:
return restaurant
else:
restaurant = Restaurant(latitude=latitude,
longitude=longitude,
name=name,
price=price,
location=location,
phone=phone,
image=image,
yelp_id=yelp_id)
db.session.add(restaurant)
db.session.commit()
return restaurant
def saving_restaurant_results():
"""save a specific restaurant to the database"""
r_name = request.form.get('name')
r_location = request.form.get('address')
r_rating = request.form.get('rating')
r_price = request.form.get('price')
nightout_id = request.form.get('nightoutId')
new_restaurant = Restaurant.query.filter_by(r_name=r_name,
r_location=r_location).first()
if not new_restaurant:
new_restaurant = Restaurant(r_name=r_name,
r_rating=r_rating,
r_location=r_location,
r_price=r_price)
db.session.add(new_restaurant)
db.session.commit()
nightout = NightOut.query.get(nightout_id)
#could also put nightout.res_id = new_restaurant.res_id
nightout.restaurant = new_restaurant
db.session.commit()
return jsonify({"sucess": True})
def load_restaurants(city):
"""Get all restaurants for a city from Yelp and load restaurants into database."""
# Get city id, as city id is a required parameter when adding a restaurant to the database
city_id = get_city_id(city)
# Start offset at 0 to return the first 20 results from Yelp API request
offset = 0
# Get total number of restaurants for this city
total_results = get_restaurants(city, offset).total
# Get all restaurants for a city and load each restaurant into the database
# Note: Yelp has a limitation of 1000 for accessible results, so get total results
# if less than 1000 or get only 1000 results back even if there should be more
while 1000 > offset < total_results:
# API response returns a SearchResponse object with accessible attributes
# response.businesses returns a list of business objects with further attributes
for business in get_restaurants(city, offset).businesses:
restaurant = Restaurant(
city_id=city_id,
name=business.name,
address=" ".join(business.location.display_address),
phone=business.display_phone,
image_url=business.image_url,
latitude=business.location.coordinate.latitude,
longitude=business.location.coordinate.longitude)
db.session.add(restaurant)
# Yelp returns only 20 results each time, so need to offset by 20 while iterating
offset += 20
db.session.commit()
def get_fake_restaurants():
"""Create 2 fake restaurants to check if those restaurants are not in Yelp"""
fake_rest1 = Restaurant(yelp_restaurant_id='111111aaaaaa',
name='Rest fake 1',
address='nowhere',
zipcode='94118',
rating=4)
fake_rest2 = Restaurant(yelp_restaurant_id='222222bbbbbb',
name='Rest fake 2',
address='far away',
zipcode='94118',
rating=5)
db.session.add_all([fake_rest1, fake_rest2])
db.session.commit()
def create_restaurant(yelp_id):
"""Create and return a new restaurant."""
res = Restaurant(yelp_id=yelp_id)
db.session.add(res)
db.session.commit()
return res
def sample_restaurant():
""" Add sample restaurant to DB """
print "Sample Restaurant"
restaurant = Restaurant(yelp_biz_id='wGl_DyNxSv8KUtYgiuLhmA',
name='Bi-Rite Creamery')
db.session.add(restaurant)
db.session.commit()
def restaurant():
restaurant = Restaurant(latitude=45,
longitude=-122,
name='New Restaurant',
price=4,
location='Test, Vancouver, WA',
phone='1234567890',
image='rest.jpg',
yelp_id='1234')
return restaurant
def newRestaurant():
if 'username' not in login_session:
return redirect('/login')
if request.method == 'POST':
newRestaurant = Restaurant(name=request.form['name'],
user_id=login_session['user_id'])
session.add(newRestaurant)
flash('New Restaurant %s Successfully Created' % newRestaurant.name)
session.commit()
return redirect(url_for('showRestaurants'))
else:
return render_template('newRestaurant.html')
def __parse_single_restaurant(li):
"""
下記の形式のHTMLをParseする。
<li>
<a href='****' title='****の待ち時間'>
<ul>
<li class='photo'><img data-src='****' width='64' height='64' class='lozad' alt='***'></li>
<li class='desc'>
<h4>レストラン名称</h4>
<p>運営ステータス<br> <span class='runtime'>11:00-17:45</span></p>
</li>
</ul>
</a>
</li>
"""
restaurant = Restaurant()
if elem_desc := li.find(class_='desc'):
# レストラン名称
restaurant.name = elem_desc.find('h4').text
for child in elem_desc.children:
if not child:
continue
if not child.text:
continue
# 中止フラグ
if "中止" in child.text:
restaurant.disable_flag = True
# ステータス・営業時間
if "-" in child.text and ":" in child.text:
splited_result = child.text.split(" ")
if len(splited_result) == 2:
restaurant.status, start_end_time = child.text.split(
" ")
restaurant.start_time, restaurant.end_time = start_end_time.split(
"-")
else:
restaurant.status = child.text.strip()
# リアルタイム待ち時間
if elem_time := li.find(class_='time'):
wait_time_str = elem_time.find('p').text.strip('待ち時間').strip(
"分")
# 時間に幅がある場合は最も大きい値をとる
if "-" in wait_time_str:
wait_time_min, wait_time_max = wait_time_str.split("-")
wait_time_str = wait_time_max if wait_time_max != "" else wait_time_min
if wait_time_str.strip() != "":
restaurant.wait_time = int(wait_time_str)
def create_restaurant(id, name, cuisine, address, longitude, latitude,
image_url):
"""Create and return a new restaurant."""
r = Restaurant(id=id,
name=name,
cuisine=cuisine,
address=address,
longitude=longitude,
latitude=latitude,
image_url=image_url)
db.session.add(r)
db.session.commit()
return r
def load_test_data():
t_user = User(username='******',
email='*****@*****.**',
password='******')
db.session.add(t_user)
t_trail = Trail(latitude=45,
longitude=-122,
name='New Trail',
length=30,
location='Vancouver, WA',
image='trail.jpg',
hiking_id='1234')
db.session.add(t_trail)
t_restaurant = Restaurant(latitude=45,
longitude=-122,
name='New Restaurant',
price=4,
location='Test, Vancouver, WA',
phone='1234567890',
image='rest.jpg',
yelp_id='1234')
db.session.add(t_restaurant)
t_walk = Walk(user=t_user, walk_date=datetime.datetime(2020, 5, 17))
db.session.add(t_walk)
t_rest_rating = RestRating(restaurant=t_restaurant,
user=t_user,
rest_comment='Wow, what a restaurant.',
rest_star=5,
masks_worn=True,
socially_distanced=True,
outdoor_seating=True)
db.session.add(t_rest_rating)
t_trail_rating = TrailRating(trail=t_trail,
user=t_user,
trail_comment='Wow, what a trail.',
trail_star=5,
difficulty_level=3,
crowded=False)
db.session.add(t_trail_rating)
db.session.commit()
def get_restaurant_id(yelp_id, rest_name):
""" Finds restaurant_id for restaurants, adds restaurant if not yet in table """
existing_restaurant = Restaurant.query.filter(Restaurant.yelp_biz_id == yelp_id).all()
if len(existing_restaurant) == 1:
print "Existing"
restaurant_id = existing_restaurant[0].restaurant_id
return restaurant_id
elif len(existing_restaurant) == 0:
print "New"
restaurant = Restaurant(yelp_biz_id=yelp_id, name=rest_name)
db.session.add(restaurant)
db.session.commit()
return get_restaurant_id(yelp_id, rest_name)
def add_rest_to_db():
"""Add all restaurants and info to the database."""
for restaurant in restaurants:
info = restaurants[restaurant]
address = ', '.join(info['address'])
category = Restaurant(rest_id=info['rest_id'],
rest_title=info['rest_title'],
rest_alias=info['rest_alias'],
rating=info['rating'],
num_reviews=info['num_reviews'],
address=address,
phone=info['phone'])
db.session.add(category)
db.session.commit()
def load_restaurants():
"""Load restaurants from seed_restaurants into database."""
print "Restaurants"
Restaurant.query.delete()
for row in open("seed/seed_restaurants.txt"):
row = row.rstrip()
restaurant_id, name, address, delivery_fee = row.split("|")
restaurant = Restaurant(restaurant_id=restaurant_id,
name=name,
address=address,
delivery_fee=delivery_fee)
db.session.add(restaurant)
db.session.commit()
def create_restaurants_list_from_restaurant_json(restaurants):
"""Create restaurants list from YELP restaurants.
restaurants(json)
return list of restaurants
"""
restaurants_list = []
for restaurant in restaurants['businesses']:
new_restaurant = Restaurant(yelp_restaurant_id=restaurant['id'],
name=restaurant['name'].lower(),
address=restaurant['location']['address1'],
zipcode=restaurant['location']['zip_code'],
rating=restaurant['rating'])
restaurants_list.append(new_restaurant)
return restaurants_list
def load_restaurant(file):
"""Load movies from u.item into database."""
print("Restaurants")
for row in open(file):
row = row.rstrip()
restaurant_name, location, zone, latitude, longitude = row.split(",")
restaurant = Restaurant(
restaurant_name = restaurant_name,
location = location,
zone = zone,
latitude =latitude,
longitude = longitude)
db.session.add(restaurant)
db.session.commit()
def _parse_restaurant(self, restaurant_soup):
restaurant = Restaurant()
# name and url
title_soup = restaurant_soup.find('a', class_='property_title')
if title_soup is not None:
restaurant.name = title_soup.text.strip()
restaurant.url = self.base_url + title_soup['href'].strip()
# price
price_soup = restaurant_soup.find('span', class_='price_range')
if price_soup is not None:
restaurant.price = price_soup.text.strip()
# reviews
reviews_soup = restaurant_soup.find('span', class_='reviewCount')
restaurant.review_count = 0
if reviews_soup is not None:
reviews_match = re.findall('^\d+\.?\d+', reviews_soup.a.text.strip())
if reviews_match and len(reviews_match) > 0:
restaurant.review_count = reviews_match[0].replace('.', '')
# rating
rating_soup = restaurant_soup.find('img', class_='sprite-ratings')
if rating_soup is not None:
rating = rating_soup['alt'].strip()
restaurant.rating = self._parse_rating(rating)
restaurant.max_rating = self._parse_max_rating(rating)
# ranking
ranking_soup = restaurant_soup.find('div', class_='popIndexDefault')
if ranking_soup is not None:
ranking = ranking_soup.text.strip().replace('.', '')
restaurant.ranking = self._parse_ranking(ranking)
restaurant.ranking_len = self._parse_ranking_len(ranking)
# cuisines
cuisine_soup_list = restaurant_soup.find_all('a', class_='cuisine')
if cuisine_soup_list is not None:
restaurant.cuisines = []
for tag in cuisine_soup_list:
restaurant.cuisines.append(tag.text.strip())
return restaurant
def import_restaurants_from_hardcode_list():
"""Load restaurant info into database model.
Additional details:
Importing name, address, phone number from hard coded data/restaurants.txt
Using phone number, importing restaurant information from Yelp API"""
hc_yelp_object_list = []
# Parse through restaurants.txt and clean/unpack data
for i, row in enumerate(open("data/restaurants.txt")):
row = row.strip()
name, address, phone = row.split("|")
# Reformat phone number from "(XXX) XXX-XXXX" to "+1XXXXXXXXXX"
yelp_phone = "+1" + phone[1:4] + phone[6:9] + phone[10:]
# Return response dictionary from Yelp API for given phone number
# Print how long the API call took
start_time = time() * 1000
yelp_dict = yelp_client.phone_search(yelp_phone)
elapsed_time = (time() * 1000) - start_time
print "API request %d: %d ms" % (i, elapsed_time)
# Return single business in response dictionary that matches the
# name and address from restaurants.txt
yelp_object = validate_single_business(yelp_dict, name, address)
# Add yelp_object to hc_yelp_object_list to be used later
hc_yelp_object_list.append(yelp_object)
# Get restaurant information for each yelp_object
yelp_id = yelp_object.id
city = yelp_object.location.city
state_code = yelp_object.location.state_code
country_code = yelp_object.location.country_code
yelp_url = yelp_object.url
yelp_img_url = yelp_object.image_url
yelp_rating = yelp_object.rating
yelp_rating_img = yelp_object.rating_img_url_small
yelp_review_count = yelp_object.review_count
lat = yelp_object.location.coordinate.latitude
lng = yelp_object.location.coordinate.longitude
# Instantiate new Restaurant object with unpacked data
restaurant = Restaurant(name=name,
address=address,
city=city,
state_code=state_code,
country_code=country_code,
phone=phone,
yelp_id=yelp_id,
yelp_url=yelp_url,
yelp_img_url=yelp_img_url,
yelp_rating=yelp_rating,
yelp_rating_img=yelp_rating_img,
yelp_review_count=yelp_review_count,
lat=lat,
lng=lng)
# Add new restaurant to database session (to be stored)
db.session.add(restaurant)
# Commit the additions to the database
db.session.commit()
return hc_yelp_object_list
def import_restaurants_from_dataset():
"""Import dog-friendly restaurants from Yelp Challenge Dataset."""
ds_yelp_object_list = []
# Parse through Yelp businesses dataset
for i, b in enumerate(open('data/yelp_academic_dataset_business.json')):
b = json.loads(b.strip())
try:
# Get only restaurant objects with dogs allowed attribute,
# and get desired values
if b["attributes"]["Dogs Allowed"] and "Restaurants" in b[
"categories"]:
ds_yelp_id = b["business_id"]
name = b["name"]
lat = b["latitude"]
lng = b["longitude"]
# Get Yelp response object of businesses with matching coordinates
start_time = time() * 1000
yelp_objects = yelp_client.search_by_coordinates(
lat, lng).businesses
elapsed_time = (time() * 1000) - start_time
print "Row %d: %d ms" % (i, elapsed_time)
# Get only one restaurant object with matching name,
# and get desired values
for y in yelp_objects:
try:
if name == y.name:
address = y.location.address[0]
city = y.location.city
state_code = y.location.state_code
country_code = y.location.country_code
phone = "(" + y.phone[:3] + ") " + y.phone[
3:6] + "-" + y.phone[6:]
yelp_id = y.id
yelp_url = y.url
yelp_img_url = y.image_url
yelp_rating = y.rating
yelp_rating_img = y.rating_img_url_small
yelp_review_count = y.review_count
# Add yelp_object to hc_yelp_object_list to be used later
ds_yelp_object_list.append(y)
# Instantiate new restaurant object and add to db.
restaurant = Restaurant(
name=name,
address=address,
city=city,
state_code=state_code,
country_code=country_code,
phone=phone,
yelp_id=yelp_id,
ds_yelp_id=ds_yelp_id,
yelp_url=yelp_url,
yelp_img_url=yelp_img_url,
yelp_rating=yelp_rating,
yelp_rating_img=yelp_rating_img,
yelp_review_count=yelp_review_count,
lat=lat,
lng=lng)
db.session.add(restaurant)
db.session.commit()
except (
sqlalchemy.exc.IntegrityError, # if not unique
sqlalchemy.exc.DataError, # if null values
IndexError
): # if weird formatting with address/phone
db.session.rollback()
except KeyError: # if no "Dogs Allowed" attribute
continue
return ds_yelp_object_list
def profile():
my_form = ProfileForm()
my_data = Profile()
my_data.remove_none_values()
# print("my_form.validate_on_submit()", my_form.validate_on_submit())
# print(my_form.errors)
if my_form.validate_on_submit():
# print("************ FORM SUBMITTED****")
my_data.first_name = request.form.get('first_name')
my_data.last_name = request.form.get('last_name')
my_data.email = request.form.get('email')
my_data.dob = request.form.get('dob')
# print("first_name", my_data.first_name)
# print("last_name", my_data.last_name)
# process file
file = request.files.get('file_photo')
if file:
orig_filename = secure_filename(file.filename)
file_extension = os.path.splitext(orig_filename)
file_extension = str(file_extension[1]).lower()
new_filename = str(uuid.uuid1()) + file_extension
# save to upload folder
file.save(os.path.join(app.config['UPLOAD_FOLDER'], new_filename))
# print("file saved")
my_data.file_photo_filename = orig_filename
my_data.file_photo_code = new_filename
# ---------------EXCEL/CSV - Load into table
data_file = request.files.get('excel_file')
print("data_file", data_file)
if data_file:
orig_filename = secure_filename(data_file.filename)
file_extension = os.path.splitext(orig_filename)
file_extension = str(file_extension[1]).lower()
new_filename = str(uuid.uuid1()) + file_extension
file_full_path = os.path.join(app.config['UPLOAD_FOLDER'],
new_filename)
# save to upload folder
data_file.save(file_full_path)
# print("file_full_path", file_full_path)
my_data.file_data_filename = orig_filename
my_data.file_data_code = new_filename
# load the data in the table using pandas
df = pd.read_csv(file_full_path)
rest_list_raw = df.to_dict('records')
rest_list = []
for rest in rest_list_raw:
my_rest = Restaurant()
my_rest.bill = rest['bill']
my_rest.tip = rest['tip']
rest_list.append(my_rest)
db.session.bulk_save_objects(rest_list)
db.session.commit()
# save to database
db.session.add(my_data)
db.session.commit()
# print("my_data", my_data.id)
# redirect to display page
return redirect('/profile/' + str(my_data.id)) # profile/5
return render_template('profile.html', my_form=my_form, my_data=my_data)
def restaurants_create():
data = request.json
print(data)
DB['restaurant'].append(Restaurant("ABC", 5))
return Response(status=200)
def load_restaurants():
""" Load restaurant and bakery data into database. """
neighborhood_list = Neighborhood.query.all()
for neighborhood in neighborhood_list:
# Make a GET request to the API
payload = {
'location': neighborhood.neighborhood_name + ' san francisco',
'categories': 'gluten_free,bakeries'
}
# r1 returns <Response 200>
r1 = requests.get('https://api.yelp.com/v3/businesses/search',
headers={'Authorization': 'Bearer %s' % api_key},
params=payload)
# results1.keys() is [u'region', u'total', u'businesses']
results1 = r1.json()
bakeries = results1['businesses']
for bakery in bakeries:
name = bakery['name']
addresses = bakery['location'][
'display_address'] # location key has a dict value
phone_number = bakery['display_phone']
picture = bakery['image_url']
website_url = bakery['url']
avg_rating = bakery['rating']
nh = neighborhood.neighborhood_id
latitude = bakery['coordinates']['latitude']
longitude = bakery['coordinates']['longitude']
price = bakery['price']
transactions = bakery['transactions']
id_b = bakery['id']
titles = bakery['categories']
alias = []
for title in titles:
if title['title']:
alias.append(title['title'])
# Convert alias (datatype is list) to a string for correct format to store in db
types_of_food = ' '.join(alias)
# Convert addresses (datatype is list) to a string for correct format to store in db
address = ' '.join(addresses)
# Second request to API to get hours of operation data
url = 'https://api.yelp.com/v3/businesses/{}'.format(id_b)
headers = {'Authorization': 'Bearer %s' % api_key}
r2 = requests.get(url, headers=headers)
results2 = r2.json()
data = results2.get('hours')
if data:
dictionary = data[0]
lst = dictionary.get('open')
if lst:
hours_of_operation = lst
else:
print dictionary.keys()
bakery_info = Restaurant(name=name,
address=address,
phone_number=phone_number,
picture=picture,
website_url=website_url,
avg_rating=avg_rating,
neighborhood_id=nh,
latitude=latitude,
longitude=longitude,
price=price,
transactions=transactions,
types_of_food=types_of_food,
hours_of_operation=hours_of_operation)
# Add bakery data to the database.
db.session.add(bakery_info)
db.session.flush()
bakery_info_id = bakery_info.restaurant_id
gf_type_bakery = Restaurant_type(gf_type_id=3,
restaurant_id=bakery_info_id)
db.session.add(gf_type_bakery)
db.session.commit()
for neighborhood in neighborhood_list:
# Make a GET request to the API
payload = {
'location': neighborhood.neighborhood_name + 'san francisco',
'categories': 'gluten_free,restaurants'
}
# r2 returns <Response 200>
r3 = requests.get('https://api.yelp.com/v3/businesses/search',
headers={'Authorization': 'Bearer %s' % api_key},
params=payload)
# results2.keys() is [u'region', u'total', u'businesses']
results3 = r3.json()
restaurants = results3['businesses']
for restaurant in restaurants:
name = restaurant['name']
addresses = restaurant['location'][
'display_address'] # location key has a dict value
phone_number = restaurant['display_phone']
picture = restaurant['image_url']
website_url = restaurant['url']
avg_rating = restaurant['rating']
nh = neighborhood.neighborhood_id
latitude = restaurant['coordinates']['latitude']
longitude = restaurant['coordinates']['longitude']
price = restaurant['price']
transactions = restaurant['transactions']
id_r = restaurant['id']
titles = restaurant['categories']
alias = []
for title in titles:
if title['title']:
alias.append(title['title'])
# Convert alias (datatype is list) to a string for correct format to store in db
types_of_food = ' '.join(alias)
# Convert addresses (datatype is list) to a string for correct format to store in db
address = ' '.join(addresses)
# Second request to API to get hours of operation data
url = 'https://api.yelp.com/v3/businesses/{}'.format(id_r)
headers = {'Authorization': 'Bearer %s' % api_key}
r2 = requests.get(url, headers=headers)
results2 = r2.json()
data = results2.get('hours')
if data:
dictionary = data[0]
lst = dictionary.get('open')
if lst:
hours_of_operation = lst
else:
print dictionary.keys()
restaurant_info = Restaurant(name=name,
address=address,
phone_number=phone_number,
picture=picture,
website_url=website_url,
avg_rating=avg_rating,
neighborhood_id=nh,
latitude=latitude,
longitude=longitude,
transactions=transactions,
price=price,
types_of_food=types_of_food,
hours_of_operation=hours_of_operation)
# Add restaurant data to the database.
db.session.add(restaurant_info)
db.session.flush()
restaurant_info_id = restaurant_info.restaurant_id
gf_type_restaurant = Restaurant_type(
gf_type_id=2, restaurant_id=restaurant_info_id)
db.session.add(gf_type_restaurant)
db.session.commit()
def Add_Restaurant(name, location, foods):
restaurant_object = Restaurant(Name=name, Location=location, Foods=foods)
session.add(restaurant_object)
session.commit()
