def post(self):
upload_files = self.get_uploads('file')
blob_info = upload_files[0]
#blob_reader = blob_info.open()
#lines = ''
#for line in blob_reader:
# Business b;
with blob_info.open() as input:
result = zip((line.split('\t') for line in input))
for line in result:
logging.info(len(line))
b = Business(name = line[0][0], latitude = line[0][1], longitude = line[0][2], address = line[0][3], city = line[0][4], zipCode = line[0][5], status = line[0][6], comment = line[0][7])
b.put()
def get(self):
if users.get_current_user():
url = users.create_logout_url(self.request.uri)
url_linktext = 'Logout'
authenticated = True
else:
url = users.create_login_url(self.request.uri)
url_linktext = 'Login'
authenticated = False
dbmarkers = Business.query().fetch()
markers = []
for marker in dbmarkers:
markers.append({'name':marker.name,
'latitude':marker.latitude,
'longitude':marker.longitude,
'address':marker.address,
'city':marker.city,
'zipCode':marker.zipCode,
'statuses':marker.statuses,
'comment':marker.comment,
'status':marker.status
# 'key':marker.key
})
template_values = {
'url': url,
'url_linktext': url_linktext,
'authenticated': authenticated,
'markers': json.dumps(markers),
}
logging.getLogger().setLevel(logging.DEBUG)
logging.info(markers)
template = JINJA_ENVIRONMENT.get_template('index.html')
self.response.write(template.render(template_values))
def add_saved_business_to_yp_session():
yelphelper_session_id = session['yelphelper_session_id']
saved_business_id = request.form.get('saved-business-id')
saved_business = SavedBusiness.query.get(saved_business_id)
yelp_id = saved_business.business.yelp_id
business = yelp_api.business_details(yelp_id)
yp_session_businesses = crud.get_businesses_by_yelphelper_session_id(
yelphelper_session_id)
msg = 'success'
for session_business in yp_session_businesses:
if session_business.alias == business['alias']:
msg = 'already added'
if msg == 'success':
alias = business.get("alias")
name = business.get("name")
yelp_id = business.get("id")
image_url = business.get("image_url")
url = business.get("url")
review_count = business.get("review_count")
yelp_rating = business.get("rating")
price = len(business.get("price"))
address = business.get("location").get("display_address")
lat = business.get("coordinates").get("latitude")
lng = business.get("coordinates").get("longitude")
new_business = Business(yelp_id=yelp_id, alias=alias, name=name, image_url=image_url,
url=url, review_count=review_count,
yelp_rating=yelp_rating, price=price,
address=address,
lat=lat, lng=lng,
yelphelper_session_id=yelphelper_session_id)
db.session.add(new_business)
db.session.commit()
return {"msg": msg}
def load_biz():
"""Load businesses from mini_biz into database."""
print 'Business'
# Delete all rows in table, so if we need to run this a second time,
# we won't be trying to add duplicate users
Business.query.delete()
# Read user file and insert data
for i, row in enumerate(open('data/test_data/mini_biz.csv', 'rU')):
row = row.rstrip()
biz_id, biz_name, address, city, state, country, zipcode, email, valid_email, phone, days_open, open_time, close_time, claimed = row.split(',')
biz = Business(biz_name=biz_name,
address=address,
city=city,
state=state,
country=country,
zipcode=zipcode,
email=email,
valid_email=valid_email,
phone=phone,
days_open=days_open,
open_time=int(open_time),
close_time=int(close_time),
claimed=claimed)
# Add each business to the session
db.session.add(biz)
# Commit at end
db.session.commit()
def load_businesses():
"""Load SF business data to Business table"""
print("Businesses")
# Delete all rows in table, so if we need to run this a second time,
# we won't be trying to add duplicate users
Business.query.delete()
# Insert API data
for i, result in enumerate(results):
#if description is 'Food Services' and there is no end date for business permit or location
if result.get('naic_code_description',
None) == 'Food Services' and result.get(
'dba_end_date', None) == None and result.get(
'location_end_date', None) == None:
# print(result.get('naic_code_description', None)) #check that you're pulling food services as naic_code_description
# asdfadf = result.get('location',{}).get('human_address', {})
# print(asdfadf)
business = Business(
ttxid=result['ttxid'],
certificate_number=result.get('certificate_number', None),
ownership_name=result.get('ownership_name', None),
dba_name=shorten_dba_name(result.get('dba_name', None)),
full_business_address=result.get('full_business_address',
None),
city=fix_city(result.get('city', None)),
state=result.get('state', None),
business_zip=result.get('business_zip', None),
dba_start_date=convert_date(result.get('dba_start_date',
None)),
location_start_date=convert_date(
result.get('location_start_date', None)),
dba_end_date=convert_date(result.get('dba_end_date', None)),
location_end_date=convert_date(
result.get('location_end_date', None)),
naic_code=result.get('naic_code', None),
naic_code_description=result.get('naic_code_description',
None),
lic=result.get('lic', None),
lic_code_description=result.get('lic_code_description', None),
location=str(result.get('location', None)),
longitude=result.get('location', {}).get('longitude', None),
latitude=result.get('location', {}).get('latitude', None),
# human_address_address=str(json.loads(result.get('location',{}).get('human_address', {})).get('address', None)),
# human_address_city=str(json.loads(result.get('location',{}).get('human_address', {})).get('address', None)),
# human_address_zip=str(json.loads(result.get('location',{}).get('human_address', {})).get('address', None)),
neighborhoods_analysis_boundaries=result.get(
'neighborhoods_analysis_boundaries', None),
business_corridor=result.get('business_corridor', None),
computed_region_6qbp_sg9q=result.get(
'computed_region_6qbp_sg9q', None))
# We need to add to the session or it won't ever be stored
db.session.add(business)
print(i)
# Once we're done, we should commit our work
db.session.commit()
def add_business_to_database(business_id, name, business_type, latitude,
longitude):
"""Add business to the database"""
business = Business(business_id=business_id,
business_name=name,
business_type=business_type,
latitude=latitude,
longitude=longitude)
db.session.add(business)
db.session.commit()
def get(self):
name = self.request.get('name')
address = self.request.get('address')
status = self.request.get('status')
dbmarkers = Business.query(Business.address == address, Business.name == name).fetch()
logging.getLogger().setLevel(logging.DEBUG)
logging.info(name)
logging.info(address)
logging.info(status)
logging.info(dbmarkers)
for marker in dbmarkers:
marker.status = status
marker.put()
self.response.write('success')
def create_business(yelp_id, yelp_alias, name, image_url, url, review_count,
rating, price, categories, distance, display_address):
"""creata a business with yelp details."""
business = Business(yelp_id=yelp_id,
yelp_alias=yelp_alias,
name=name,
image_url=image_url,
url=url,
review_count=review_count,
rating=rating,
price=price,
categories=categories,
distance=distance,
display_address=display_address)
db.session.add(business)
db.session.commit()
return business
def populate_business():
"""Create minimum sample data for the business table."""
# always clean slate test data
Business.query.delete()
businesses = [{
'business_name': 'Lobodogwalks',
'business_street': '43621 Pacific Commons Blvd.',
'business_city': 'Fremont',
'business_state': 'CA',
'business_zip': '94538',
'business_phone': '510111111',
'url': 'http://Lobodogwalks.com',
'license': 'def567'
}, {
'business_name': 'Ruff Tails',
'business_street': '4801 Central Ave.',
'business_city': 'Richmond',
'business_state': 'CA',
'business_zip': '94804',
'business_phone': '5102222222',
'url': 'http://rufftails.com',
'license': 'abc123'
}]
for business in businesses:
b = Business(business_name=business['business_name'],
business_street=business['business_street'],
business_city=business['business_city'],
business_state=business['business_state'],
business_zip=business['business_zip'],
business_phone=business['business_phone'],
url=business['url'],
license=business['license'])
db.session.add(b)
db.session.commit()
return None
def load_data(row):
"""populate db with data from csv file"""
name, address, categories = row[1:4]
business = Business(name=name, address=address)
for c in categories.split(", "):
# checking if category is already in db
categories_in_db = Category.query.filter(Category.category == c).all()
if not categories_in_db:
category = Category(category=c)
# adding data to the association table
business.business_categories.append(category)
db.session.add(business)
db.session.commit()
def load_data(row):
"""populate db with data from csv file"""
name, address, categories = row[1:4]
lat_lng = get_lat_lng(address)
business = Business(name=name,
address=address,
lat=lat_lng["lat"],
lng=lat_lng["lng"])
for category in categories.split(", "):
# getting all existing category objects in the db
categories_in_db = Category.get_all_categories()
list_of_categories_in_db = [c.category for c in categories_in_db]
# checking if category is already in db
if category not in list_of_categories_in_db:
category = Category(category=category)
else:
category = Category.get_category_by_name(category)
# adding data to the association table
if isinstance(category, list):
for single_category in category:
single_category.categories_business.append(business)
db.session.add(single_category)
else:
category.categories_business.append(business)
db.session.add(category)
db.session.commit()
def get_business_info():
"""return a json element with businesses associated to the given category"""
category = request.args.get("searchTerm", "")
try:
# get category object with search term
category_object = Category.get_category_by_name(category)
except NoResultFound:
return jsonify({"data": "Can't find matches"})
# getting businesses associated with elected category
try:
businesses = category_object.categories_business
# when we have multiple matches, we get a list -> categories_business throws
# AttributeError (list does not have that attribute
except AttributeError:
# todo: turn list of objects into one big object to pass to JS
return jsonify({"data": "Can't find matches"})
return jsonify(Business.serialize_business_object(businesses))
def show_business_details(business_id):
"""Shows detailed information about a selected business"""
business = Business.get_business_by_id(business_id)
return render_template("business_details.html", business=business)
def retrieve_businesses():
yelphelper_session_id = session['yelphelper_session_id']
yelphelper_session = YelpHelperSession.query.get(yelphelper_session_id)
users_locations = crud.get_users_locations(yelphelper_session_id)
center_point = distance_matrix_api.find_center_point(users_locations)
max_duration = yelphelper_session.max_duration
search_criterias = yelphelper_session.search_criterias
yelp_api_responses = []
for search_criteria in search_criterias:
businesses = yelp_api.business_search(
center_point.get("lat"), center_point.get("lng"), search_criteria.term, search_criteria.price)
yelp_api_responses.append(businesses)
all_businesses = list(
map(list, itertools.zip_longest(* yelp_api_responses, fillvalue=None)))
all_businesses = sum(all_businesses, [])
all_businesses = [x for x in all_businesses if x is not None]
if len(search_criterias) == 0:
businesses = yelp_api.business_search(
center_point.get("lat"), center_point.get("lng"), 'food')
all_businesses = businesses
if len(all_businesses) >= 25:
businesses_batch = all_businesses[:25]
all_businesses[:25] = []
else:
businesses_batch = all_businesses
all_businesses = []
businesses_locations = []
for business in businesses_batch:
businesses_locations.append({"lat": business.get("coordinates").get(
"latitude"), "lng": business.get("coordinates").get("longitude")})
distance_matrix_response = distance_matrix_api.return_distances(
businesses_locations, users_locations)
# print(distance_matrix_response)
existing_businesses_count = len(yelphelper_session.businesses)
businesses_left = 10 - existing_businesses_count
msg = "success"
while businesses_left > 0:
for index, business in enumerate(businesses_batch):
alias = business.get("alias")
# fetch all of this at once - database query are expensive. reduce amount of time query database.
business_already_added = db.session.query(Business).filter_by(
yelphelper_session=yelphelper_session, alias=alias).first()
if not business_already_added:
meet_duration_criteria = distance_matrix_api.check_below_max_duration(
distance_matrix_response, index, max_duration)
if meet_duration_criteria:
name = business.get("name")
yelp_id = business.get("id")
image_url = business.get("image_url")
url = business.get("url")
review_count = business.get("review_count")
yelp_rating = business.get("rating")
if business.get("price"):
price = len(business.get("price"))
else:
price = None
address = business.get("location").get("display_address")
lat = business.get("coordinates").get("latitude")
lng = business.get("coordinates").get("longitude")
new_business = Business(yelp_id=yelp_id, alias=alias, name=name, image_url=image_url,
url=url, review_count=review_count,
yelp_rating=yelp_rating, price=price,
address=address,
lat=lat, lng=lng,
yelphelper_session_id=yelphelper_session_id)
db.session.add(new_business)
db.session.commit()
businesses_left -= 1
print(businesses_left)
if businesses_left <= 0:
break
if businesses_left <= 0:
break
elif len(all_businesses) >= 25:
businesses_batch = all_businesses[:25]
all_businesses[:25] = []
elif 25 > len(all_businesses) > 0:
businesses_batch = all_businesses
all_businesses = []
else:
msg = "fail"
break
businesses_locations = []
for business in businesses_batch:
businesses_locations.append({"lat": business.get("coordinates").get(
"latitude"), "lng": business.get("coordinates").get("longitude")})
distance_matrix_response = distance_matrix_api.return_distances(
businesses_locations, users_locations)
return {'msg': msg}
def biz_process():
"""Processes new business request."""
# Get form variables
name = request.form['name']
address = request.form['addy']
city = request.form['city']
state = request.form['state']
country = request.form['country']
zipcode = request.form['zipcode']
phone = request.form['tel']
email = request.form['email']
url = request.form['url']
category = request.form['category']
days_open = request.form['days-open']
open_time = int(request.form['time-open'])
open_mil = request.form['open-ampm']
close_time = int(request.form['time-close'])
close_mil = request.form['close-ampm']
claim = request.form['claim']
# Convert picture that would be saved to static/img directory but url stored
# in database
if 'pic' in request.files:
filename = pics.save(request.files['pic'])
pic = pics.url(filename)
else:
pic = None
# Convert time to military format
if open_mil == 'pm':
open_time += 12
if close_mil == 'pm':
close_time += 12
# Convert phone to same format
re.sub('\ |\?|\.|\!|\/|\;|\:|\-|\(|\)', '', phone)
# Convert boolean to python format
if claim == 'true':
claim = True
else:
claim = False
# Check if business is already in database
business = Business.query.filter((Business.email == email) | (Business.biz_name == name)).first()
if business:
flash('The business name or email provided is already in BUDdy.', 'warning')
return redirect('/login')
else:
biz = Business(biz_name=name,
address=address,
city=city,
state=state,
country=country,
zipcode=zipcode,
phone=phone,
email=email,
url=url,
category=category,
days_open=days_open,
open_time=open_time,
close_time=close_time,
claimed=claim,
biz_pic=pic)
db.session.add(biz)
db.session.commit()
if claim:
userbiz = UserBiz(user_id=session['user_id'], biz_id=biz.biz_id)
db.session.add(userbiz)
db.session.commit()
flash('{} has been added'.format(biz.biz_name), 'info')
return redirect('/')
