def create_business(self, name, address):
# check business
business = Business.create(name, address)
self.created_ids.append(business.id)
self.assertTrue(business)
return business
def setUp(self):
from service import main
from paste.deploy import appconfig
from webtest import TestApp
# set settings
os.environ['PYRAMID_SETTINGS'] = 'development.ini#main'
self.settings = appconfig('config:{}'.format(os.environ['PYRAMID_SETTINGS']), relative_to='.')
app = main({}, **self.settings)
self.testapp = TestApp(app)
self.config = testing.setUp(settings=self.settings)
self.created_ids = []
# init user
self.user = User.create('*****@*****.**', 'hello')
payload = {
'email': '*****@*****.**',
'password': '******',
}
response = self.testapp.post_json('/api/v1/authenticate', payload, status=200)
self.access_token = response.json['access_token']
# init business
address = {
'street1': 'Central Park',
'city': 'New York',
'state': 'NY',
}
self.business = Business.create('Test Location', address)
def create_business(self):
address = {
'street1': 'Central Park',
'city': 'New York',
'state': 'NY'
}
business = Business.create('Central Park', address)
return business
def reset(self):
"""
clean up any remaining test users
"""
for business_id in self.created_ids:
business = Business.get_by_id(business_id)
if business:
business.delete()
def reviews_post(request):
"""
creates new business review
**authentication required with access_token**
errors
======
* status 400 - if failed to create business
returns
=======
::
{
"id": ""
}
"""
business_id = request.matchdict['business_id']
business = Business.get_by_id(business_id)
user = request.validated['user']
text = request.validated['text']
rating = request.validated['rating']
tags = request.validated['tags']
if tags:
tags = tags.split(':')
else:
tags = []
if business and user:
review = Review.create(user.id, business, rating, text, tags)
response_body = {
'id': review.id,
}
# kill cache
cache_key = 'business:{}*'.format(business.id)
redis_cache.delete_pattern(cache_key)
else:
logger.debug('Failed to create review for business:{}'.format(business_id))
request.response.status_int = 400
response_body = {
'status': 'error',
'message': 'failed to create review for business'
}
request.response.body = json.dumps(response_body, cls=ComplexEncoder)
request.response.content_type = 'application/json'
return request.response
def test_reviews(self):
review = Review.create(self.user.id, self.business, 1, 'This is a review', tags=['hello', 'world'])
self.created_ids.append(review.id)
review = Review.create(self.user.id, self.business, 5, 'This is a another review', tags=['hello', 'something'])
self.created_ids.append(review.id)
self.business = Business.get_by_id(self.business.id)
self.assertTrue(self.business.rating == 3)
self.assertTrue('hello' in self.business.tags)
self.assertTrue('world' in self.business.tags)
self.assertTrue('something' in self.business.tags)
review.delete()
self.business = Business.get_by_id(self.business.id)
self.assertTrue(self.business.rating == 1)
self.assertFalse('something' in self.business.tags)
review = Review.create(self.user.id, self.business, 5, 'This is a another review', tags=['hello', 'something'])
self.created_ids.append(review.id)
def reviews_get(request):
"""
Returns the business reviews
errors
======
* status 404 - if the business can't be found
returns
=======
::
{
"reviews": [
{
"rating": 5,
"modified": "2015-08-10T00:20:17.753000",
"id": "55c7ee41fad9b43993d71919",
"user_id": "55c7ee3dfad9b43993d7190e",
"reviewed_id": "55c7ee3efad9b43993d7190f",
"tags": [
"awesome"
],
"text": "This is awesome.",
"created": "2015-08-10T00:20:17.753000",
"reviewed_collection": "businesses"
}
]
}
"""
business_id = request.matchdict['business_id']
business = Business.get_by_id(business_id)
if business:
response_body = {
'reviews': Review.reviews_for_reviewed(business.collection, business.id)
}
logger.debug('Retrieved business:{} reviews'.format(business.id))
else:
logger.debug('Failed to retrieve business:{} reviews'.format(business_id))
request.response.status_int = 404
response_body = {
'status': 'error',
'message': 'failed to find business'
}
request.response.body = json.dumps(response_body, cls=ComplexEncoder)
request.response.content_type = 'application/json'
return request.response
def businesses_post(request):
"""
create a new business
**requires authentication with an access_token**
errors
======
* status 500 - if the user can't be saved
returns
=======
::
{
"id": ""
}
"""
user = request.validated['user']
name = request.validated['name']
address = {
'street1': request.validated['street1'],
'street2': request.validated['street2'],
'city': request.validated['city'],
'state': request.validated['state'],
'postal_code': request.validated['postal_code'],
}
business = Business.create(name, address)
if business:
logger.debug('Created new business:{}'.format(business.id))
response_body = {
'id': business.id
}
else:
logger.debug('Failed to create new business.')
requests.response.status_int = 500
response_body = {
'status': 'error',
'message': 'failed to create new business',
}
request.response.body = json.dumps(response_body, cls=ComplexEncoder)
request.response.content_type = 'application/json'
return request.response
def review_get(request):
"""
Returns the business review
errors
======
* status 404 - if the review couldn't be found
returns
=======
::
{
"rating": 5,
"modified": "2015-08-10T00:20:17.753000",
"id": "55c7ee41fad9b43993d71919",
"user_id": "55c7ee3dfad9b43993d7190e",
"reviewed_id": "55c7ee3efad9b43993d7190f",
"tags": [
"awesome"
],
"text": "This is awesome.",
"created": "2015-08-10T00:20:17.753000",
"reviewed_collection": "businesses"
}
"""
business_id = request.matchdict['business_id']
review_id = request.matchdict['review_id']
business = Business.get_by_id(business_id)
review = Review.get_by_id(review_id)
if business and review and business.id == review.reviewed_id:
response_body = review.json
logger.debug('Retrieved business:{} review:{}'.format(business.id, review.id))
else:
logger.debug('Failed to retrieve business:{} review:'.format(business_id, review_id))
request.response.status_int = 404
response_body = json.dumps({
'status': 'error',
'message': 'failed to find business review'
})
request.response.body = response_body
request.response.content_type = 'application/json'
return request.response
def update_business(event):
"""
compiles rating and tags for a business when a review is updated
"""
from reviews.models import Review
review = event.review
business = Business.get_by_id(review.reviewed_id)
if business:
business.rating = Review.rating_for_reviewed(review.reviewed_id)
business.tags = Review.tags_for_reviewed(review.reviewed_id)
business.save()
logger.debug('updated business:{} reviews'.format(business.id))
else:
logger.debug('failed to update business:{} reviews'.format(review.reviewd_id))
def parse_csv(csv_filename):
with open(csv_filename) as csv_file:
reader = csv.reader(csv_file)
next(reader) # first line has the headers.
for row in reader:
yield Business(
id=int(row[0]),
uuid=row[1],
name=row[2],
address=row[3],
address2=row[4],
city=row[5],
state=row[6],
zip=row[7],
country=row[8],
phone=row[9],
website=row[10],
created_at=row[11],
)
def BusinessListView(request):
model = Business()
businesses = Business.objects.filter(user=request.user)
return render(request, 'businesses/business_list.html', {'businesses': businesses})
def refresh_business(self):
"""
loads and updates the business with the database
"""
self.business = Business.get_by_id(self.business.id)
def create_businesses():
businesses = []
address = {
'street1': 'Time Square',
'city': 'New York',
'state': 'NY'
}
business = Business.create('Time Square', address)
businesses.append(business)
address = {
'street1': 'Battery Park',
'city': 'New York',
'state': 'NY'
}
business = Business.create('Battery Park', address)
businesses.append(business)
address = {
'street1': 'Flushing Medows',
'city': 'New York',
'state': 'NY'
}
business = Business.create('Flushing Medows', address)
businesses.append(business)
address = {
'street1': 'Central Park',
'city': 'New York',
'state': 'NY'
}
business = Business.create('Central Park', address)
businesses.append(business)
address = {
'street1': '2200 Broadway',
'city': 'New York',
'state': 'NY'
}
business = Business.create('2200', address)
businesses.append(business)
address = {
'street1': '1800 Broadway',
'city': 'New York',
'state': 'NY'
}
business = Business.create('1800', address)
businesses.append(business)
address = {
'street1': '1500 Broadway',
'city': 'New York',
'state': 'NY'
}
business = Business.create('1500', address)
businesses.append(business)
address = {
'street1': '1200 Broadway',
'city': 'New York',
'state': 'NY'
}
business = Business.create('1200', address)
businesses.append(business)
return businesses
def businesses_get(request):
"""
Returns the businesses
location format = [lng, lat]
use limit and offset to paginate::
http://localhost:8000/api/v1/businesses?limit=100&offset=0
to restrict results withing a distance from a location use lat, lng, distance, and units::
http://localhost:8000/api/v1/businesses?lng=-73.988395&lat=40.7461666&distance=3
returns
=======
::
{
"businesses": [{
"rating": 2.25,
"modified": "2015-08-10T00:20:14.370000",
"address": {
"street1": "Time Square",
"postal_code": "",
"street2": "",
"city": "New York",
"state": "NY"
},
"id": "55c7ee3efad9b43993d7190f",
"location": [
-73.985131,
40.758895
],
"tags": [
"hello",
"world",
"example",
"awesome"
],
"name": "Time Square",
"created": "2015-08-10T00:20:13.760000"
}],
"count": 1
}
"""
location = []
lat = request.validated['lat']
lng = request.validated['lng']
distance = request.validated['distance']
units = request.validated['units']
limit = request.validated['limit']
offset = request.validated['offset']
# set location only if both lat and lng
if lat and lng:
location = [lng, lat]
businesses = Business.businesses(location=location, distance=distance, units=units, limit=limit, offset=offset)
# get business count to help pagination
if location:
# TODO: this count is wrong when location limiting
businesses_count = len(businesses)
else:
businesses_count = Business.count()
businesses_jsonable = []
for business in businesses:
businesses_jsonable.append(business.toJSON())
response_body = {
'businesses': businesses_jsonable,
'count': businesses_count,
}
logger.debug('Retrieved businesses')
request.response.body = json.dumps(response_body, cls=ComplexEncoder)
request.response.content_type = 'application/json'
return request.response
def business_get(request):
"""
Returns the business
errors
======
* status 404 - if the business can't be found
returns
=======
/businesses/<id>?reviews=true
::
{
"rating": 5,
"modified": "2015-08-10T00:20:14.370000",
"address": {
"street1": "Time Square",
"postal_code": "",
"street2": "",
"city": "New York",
"state": "NY"
},
"id": "55c7ee3efad9b43993d7190f",
"location": [
-73.985131,
40.758895
],
"reviews": [
{
"rating": 5,
"modified": "2015-08-10T00:20:17.753000",
"id": "55c7ee41fad9b43993d71919",
"user_id": "55c7ee3dfad9b43993d7190e",
"reviewed_id": "55c7ee3efad9b43993d7190f",
"tags": [
"awesome"
],
"text": "This is awesome.",
"created": "2015-08-10T00:20:17.753000",
"reviewed_collection": "businesses"
}
],
"tags": [
"awesome"
],
"name": "Time Square",
"created": "2015-08-10T00:20:13.760000"
}
"""
business_id = request.matchdict['business_id']
include_reviews = request.validated['reviews']
business = Business.get_by_id(business_id)
# a light redis check is an example of how queries can be further optimized
if include_reviews:
cache_key = 'business:{}:reviews-true'.format(business_id)
else:
cache_key = 'business:{}:reviews-false'.format(business_id)
cached = redis_cache.get(cache_key)
if cached and business:
response_body = cached
elif business:
response_body = business.toJSON()
if include_reviews:
response_body['reviews'] = Review.reviews_for_reviewed(business.collection, business.id)
response_body = json.dumps(response_body, cls=ComplexEncoder)
redis_cache.set(cache_key, response_body)
logger.debug('Retrieved business:{}'.format(business.id))
else:
logger.debug('Failed to retrieve business:{}'.format(business_id))
request.response.status_int = 404
response_body = json.dumps({
'status': 'error',
'message': 'failed to find business'
})
request.response.body = response_body
request.response.content_type = 'application/json'
return request.response
def reset(self):
self.user.delete()
for _id in self.created_ids:
business = Business.get_by_id(_id)
business.delete()
