def _section_helper(updatefn):
rid = request.form['rid'].strip()
title = request.form.get('title', '').strip()
notes = request.form.get('notes', '').strip()
sectidx = request.form.get('sectidx', '')
subsectidx = request.form.get('subsectidx', '')
r = Restaurant.get(rid)
if not r:
abort(404)
#print 'sectidx:', sectidx, ' subsectidx:', subsectidx
if sectidx:
if not re.match('^-?\d+$', sectidx):
abort(400)
sectidx = int(sectidx)
if sectidx >= len(r['menu']):
print 'sectidx >=', len(r['menu'])
abort(400)
else:
sectidx = -1
if subsectidx:
if not re.match('^-?\d+$', subsectidx):
abort(400)
subsectidx = int(subsectidx)
if 'subsections' in r['menu'][sectidx] and subsectidx >= len(
r['menu'][sectidx]['subsections']):
abort(400)
else:
subsectidx = -1
ret = updatefn(r, sectidx, subsectidx, title, notes)
if ret:
return ret
Restaurant.save(r)
class TestAddTest(TestCase):
def setUp(self):
self.user = User.objects.create_user("TestAddTest_User")
self.restaurant = Restaurant(name="Slippery Bannana",
contactinfo="123 Fake Street",
qrfile="nonexistent qrfile",
client_gmt_offset=1);
self.restaurant.save()
wl = WaitList(restaurant=self.restaurant);
wl.save()
self.user.restaurantAdminUser = RestaurantAdmin(nick="TestAddTest_nick",
restaurant=self.restaurant)
self.request = HttpRequest()
self.request.user = self.user
def test_add_single(self):
response = views.test_add(self.request, 1, 1, "all")
self.assertEqual(Customer.objects.count(), 1)
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], '/waitlist/current')
def test_add_many(self):
response = views.test_add(self.request, 3, 5, "checkedin_removed")
self.assertEqual(Customer.objects.count(), 15)
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], '/archive_current/')
def create(self, validated_data):
restaurant = Restaurant(
username=validated_data['username'],
email=validated_data['email'],
password=validated_data['password'],
restaurantName=validated_data['restaurantName'],
first_name=validated_data['first_name'],
last_name=validated_data['last_name'])
restaurant.save()
return restaurant
def test_issue_6755(self):
"""
Regression test for #6755
"""
r = Restaurant(serves_pizza=False)
r.save()
self.assertEqual(r.id, r.place_ptr_id)
orig_id = r.id
r = Restaurant(place_ptr_id=orig_id, serves_pizza=True)
r.save()
self.assertEqual(r.id, orig_id)
self.assertEqual(r.id, r.place_ptr_id)
def test_issue_6755(self):
"""
Regression test for #6755
"""
r = Restaurant(serves_pizza=False)
r.save()
self.assertEqual(r.id, r.place_ptr_id)
orig_id = r.id
r = Restaurant(place_ptr_id=orig_id, serves_pizza=True)
r.save()
self.assertEqual(r.id, orig_id)
self.assertEqual(r.id, r.place_ptr_id)
class WaitListTest(TestCase):
def setUp(self):
self.user = User.objects.create_user('WaitListTest_User')
self.user.save()
self.restaurant = Restaurant(name="Slippery Bannana",
contactinfo="123 Fake Street",
qrfile="nonexistent qrfile",
client_gmt_offset=1);
self.restaurant.save();
def test_add_customer(self):
wl = WaitList(restaurant=self.restaurant);
wl.save()
wl.add_customer(Customer(name="Fred", party_size=5, phone="0000000000", waitlist=wl))
wl.add_customer(Customer(name="George", party_size=2, phone="0000000000", waitlist=wl))
wl = save_load(wl);
self.assertEqual(wl.customers.count(), 2)
self.assertEqual(wl.customers.filter(name="Fred").count(), 1)
self.assertEqual(wl.customers.filter(name="George").count(), 1)
class TestArchiveCurrent(TestCase):
def setUp(self):
'''Add user data so we have something to archive'''
self.user = User.objects.create_user("TestAddTest_User")
self.restaurant = Restaurant(name="Slippery Bannana",
contactinfo="123 Fake Street",
qrfile="nonexistent qrfile",
client_gmt_offset=1);
self.restaurant.save()
wl = WaitList(restaurant=self.restaurant);
wl.save()
self.user.restaurantAdminUser = RestaurantAdmin(nick="TestAddTest_nick",
restaurant=self.restaurant)
self.request = HttpRequest()
self.request.user = self.user
views.test_add(self.request, 3, 7, "checkedin_removed")
def test_archive_current(self):
response = views.archive_current(self.request)
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], '/waitlist/current/')
class CustomerTest(TestCase):
def setUp(self):
self.user = User.objects.create_user('CustomerTest_User')
self.restaurant = Restaurant(name="Slippery Bannana",
contactinfo="123 Fake Street",
qrfile="nonexistent qrfile",
client_gmt_offset=1);
self.restaurant.save();
def test_customer_creation(self):
# Save
original_customer_count = Customer.objects.count()
wl = WaitList(restaurant=self.restaurant); wl.save()
c = Customer(name="Fred", party_size=5, phone="0000000000", waitlist=wl)
c = save_load(c)
self.assertEqual(Customer.objects.count(), original_customer_count+1)
self.assertNotEqual(c, None)
self.assertEqual(c.name, "Fred")
self.assertEqual(c.party_size, 5)
self.assertEqual(c.phone, "0000000000")
class OneToOneTests(TestCase):
def setUp(self):
self.p1 = Place(name='Demon Dogs', address='944 W. Fullerton')
self.p1.save()
self.p2 = Place(name='Ace Hardware', address='1013 N. Ashland')
self.p2.save()
self.r = Restaurant(place=self.p1, serves_hot_dogs=True, serves_pizza=False)
self.r.save()
def test_getter(self):
# A Restaurant can access its place.
self.assertEqual(repr(self.r.place), '<Place: Demon Dogs the place>')
# A Place can access its restaurant, if available.
self.assertEqual(repr(self.p1.restaurant), '<Restaurant: Demon Dogs the restaurant>')
# p2 doesn't have an associated restaurant.
self.assertRaises(Restaurant.DoesNotExist, getattr, self.p2, 'restaurant')
def test_setter(self):
# Set the place using assignment notation. Because place is the primary
# key on Restaurant, the save will create a new restaurant
self.r.place = self.p2
self.r.save()
self.assertEqual(repr(self.p2.restaurant), '<Restaurant: Ace Hardware the restaurant>')
self.assertEqual(repr(self.r.place), '<Place: Ace Hardware the place>')
self.assertEqual(self.p2.pk, self.r.pk)
# Set the place back again, using assignment in the reverse direction.
self.p1.restaurant = self.r
self.assertEqual(repr(self.p1.restaurant), '<Restaurant: Demon Dogs the restaurant>')
r = Restaurant.objects.get(pk=self.p1.id)
self.assertEqual(repr(r.place), '<Place: Demon Dogs the place>')
def test_manager_all(self):
# Restaurant.objects.all() just returns the Restaurants, not the Places.
self.assertQuerysetEqual(Restaurant.objects.all(), [
'<Restaurant: Demon Dogs the restaurant>',
])
# Place.objects.all() returns all Places, regardless of whether they
# have Restaurants.
self.assertQuerysetEqual(Place.objects.order_by('name'), [
'<Place: Ace Hardware the place>',
'<Place: Demon Dogs the place>',
])
def test_manager_get(self):
def assert_get_restaurant(**params):
self.assertEqual(repr(Restaurant.objects.get(**params)),
'<Restaurant: Demon Dogs the restaurant>')
assert_get_restaurant(place__id__exact=self.p1.pk)
assert_get_restaurant(place__id=self.p1.pk)
assert_get_restaurant(place__exact=self.p1.pk)
assert_get_restaurant(place__exact=self.p1)
assert_get_restaurant(place=self.p1.pk)
assert_get_restaurant(place=self.p1)
assert_get_restaurant(pk=self.p1.pk)
assert_get_restaurant(place__pk__exact=self.p1.pk)
assert_get_restaurant(place__pk=self.p1.pk)
assert_get_restaurant(place__name__startswith="Demon")
def assert_get_place(**params):
self.assertEqual(repr(Place.objects.get(**params)),
'<Place: Demon Dogs the place>')
assert_get_place(restaurant__place__exact=self.p1.pk)
assert_get_place(restaurant__place__exact=self.p1)
assert_get_place(restaurant__place__pk=self.p1.pk)
assert_get_place(restaurant__exact=self.p1.pk)
assert_get_place(restaurant__exact=self.r)
assert_get_place(restaurant__pk=self.p1.pk)
assert_get_place(restaurant=self.p1.pk)
assert_get_place(restaurant=self.r)
assert_get_place(id__exact=self.p1.pk)
assert_get_place(pk=self.p1.pk)
def test_foreign_key(self):
# Add a Waiter to the Restaurant.
w = self.r.waiter_set.create(name='Joe')
w.save()
self.assertEqual(repr(w), '<Waiter: Joe the waiter at Demon Dogs the restaurant>')
# Query the waiters
def assert_filter_waiters(**params):
self.assertQuerysetEqual(Waiter.objects.filter(**params), [
'<Waiter: Joe the waiter at Demon Dogs the restaurant>'
])
assert_filter_waiters(restaurant__place__exact=self.p1.pk)
assert_filter_waiters(restaurant__place__exact=self.p1)
assert_filter_waiters(restaurant__place__pk=self.p1.pk)
assert_filter_waiters(restaurant__exact=self.p1.pk)
assert_filter_waiters(restaurant__exact=self.p1)
assert_filter_waiters(restaurant__pk=self.p1.pk)
assert_filter_waiters(restaurant=self.p1.pk)
assert_filter_waiters(restaurant=self.r)
assert_filter_waiters(id__exact=self.p1.pk)
assert_filter_waiters(pk=self.p1.pk)
# Delete the restaurant; the waiter should also be removed
r = Restaurant.objects.get(pk=self.p1.pk)
r.delete()
self.assertEqual(Waiter.objects.count(), 0)
def test_multiple_o2o(self):
# One-to-one fields still work if you create your own primary key
o1 = ManualPrimaryKey(primary_key="abc123", name="primary")
o1.save()
o2 = RelatedModel(link=o1, name="secondary")
o2.save()
# You can have multiple one-to-one fields on a model, too.
x1 = MultiModel(link1=self.p1, link2=o1, name="x1")
x1.save()
self.assertEqual(repr(o1.multimodel), '<MultiModel: Multimodel x1>')
# This will fail because each one-to-one field must be unique (and
# link2=o1 was used for x1, above).
sid = transaction.savepoint()
mm = MultiModel(link1=self.p2, link2=o1, name="x1")
self.assertRaises(IntegrityError, mm.save)
transaction.savepoint_rollback(sid)
def parse_detail(self, response):
hxs = HtmlXPathSelector(response)
shopname = hxs.select('//div[@class="shop-name"]/h1/text()').extract()
tags = hxs.select('//div[@class="desc-list"]/dl/dd/span/a[contains(@href, "/search/")]/text()').extract()
address = hxs.select(
'//dl[@class="shopDeal-Info-address"]/dd/span[@itemprop="street-address"]/text()'
).extract()
# TODO need a func to decode
flavor_env_service = hxs.select('//div[@class="desc-list"]/dl/dd/em[@class="progress-value"]/text()').extract()
trans = hxs.select('//div[@class="block-inner desc-list"]/dl/dd/span[@class="J_brief-cont"]/text()').extract()
# TODO need to remove 更多
specials = hxs.select(
'//div[@class="block-inner desc-list"]/dl[@class="J_tags-fold-wrap"]/dd/span/a/text()'
).extract()
recommendations_people = hxs.select('//div[@class="rec-menu"]/span/text()').extract()
recommendations = hxs.select('//div[@class="rec-menu"]/span/a/text()').extract()
recommendation_photos = hxs.select('//div[@class="rec-slide-entry"]/ul/li/a/img/@src').extract()
score = hxs.select('//div[@class="comment-rst"]/span/meta/@content').extract()
avg_price = hxs.select('//div[@class="comment-rst"]/dl/dd/text()').extract()
collect = hxs.select('//div[@class="shop-action"]/ul/li/span/text()').extract()[0][1:-2]
code = hxs.select("//script/text()")[3].re(r"poi: \'(\w+)\'")
if code:
code = code[0]
else:
code = ""
if avg_price:
avg_price = avg_price[0]
else:
avg_price = ""
recs = [recommendations[i] + recommendations_people[i] for i in range(len(recommendations))]
if len(flavor_env_service) < 3:
flavor = ""
env = ""
service = ""
else:
flavor = flavor_env_service[0]
env = flavor_env_service[0]
service = flavor_env_service[0]
if specials:
if specials[-1] == u"更多":
specials = specials[:-1]
num = response.request.meta["num"]
try:
print("url is %s, shopname is %s %s" % (response.request.url, shopname[0], datetime.datetime.now()))
restaurant = Restaurant(
num=num,
url=response.request.url,
shop_name=shopname,
tags=tags,
address=address,
flavor=flavor,
env=env,
service=service,
specials=specials,
trans=trans,
recommendations=recs,
recommendation_photos=recommendation_photos,
shop_score=score,
avg_price=avg_price,
collect=collect,
code=code,
)
restaurant.save()
except Exception as err:
print(err)
file = open("error.log", "w")
fcntl.flock(file, fcntl.LOCK_EX)
file.write(response.request.url + "\n")
fcntl.flock(file, fcntl.LOCK_UN)
file.close()
def process_file(filehandler, delimiter=','):
"""Process CSV file to insert data into DB"""
reader = csv.reader(filehandler)
headers = next(reader)
headers = tuple(header.lower().replace(' ', '_') for header in headers)
for num, line in enumerate(reader):
record = {header: value for header, value in zip(headers, line)}
# Cast record to correct type
record['camis'] = int(record['camis'])
try:
record['score'] = int(record['score'])
except ValueError:
record['score'] = None
try:
record['inspection_date'] = datetime.datetime.strptime(
record['inspection_date'], '%m/%d/%Y')
except ValueError:
record['inspection_date'] = None
try:
record['grade_date'] = datetime.datetime.strptime(
record['grade_date'], '%m/%d/%Y')
except ValueError:
record['grade_date'] = None
try:
record['record_date'] = datetime.datetime.strptime(
record['record_date'], '%m/%d/%Y')
except ValueError:
record['record_date'] = None
record['cuisine_description'] = [
x.strip().lower() for x in record['cuisine_description'].split(',')
]
if record['violation_code']:
violation = Violation.objects(
code=record['violation_code']).first()
if violation is None:
violation = Violation(
code=record['violation_code'],
description=record['violation_description'],
critical_flag=record['critical_flag'])
violation.save()
inspection = Inspection.objects(
restaurnt_id=record['camis'],
inspection_date=record['inspection_date']).first()
if inspection is None:
inspection = Inspection(restaurnt_id=record['camis'],
inspection_date=record['inspection_date'],
action=record['action'],
score=record['score'],
grade=record['grade'],
grade_date=record['grade_date'],
record_date=record['record_date'],
type=record['inspection_type'])
inspection.save()
inspection.update(add_to_set__violations=[violation])
restaurant = Restaurant.objects(restaurnt_id=record['camis']).first()
if restaurant is None:
restaurant = Restaurant(restaurnt_id=record['camis'],
name=record['dba'],
boro=record['boro'],
building=record['building'],
street=record['street'],
zipcode=record['zipcode'],
phone=record['phone'],
cuisine=record['cuisine_description'],
grade=record['grade'],
grade_date=record['grade_date'],
record_date=record['record_date'])
restaurant.save()
elif (restaurant.grade_date is None or record['grade_date']
and record['grade_date'] > restaurant.grade_date):
restaurant.grade = record['grade']
restaurant.grade_date = record['grade_date']
restaurant.save()
restaurant.update(add_to_set__inspections=[inspection])
class OneToOneTests(TestCase):
def setUp(self):
self.p1 = Place(name='Demon Dogs', address='944 W. Fullerton')
self.p1.save()
self.p2 = Place(name='Ace Hardware', address='1013 N. Ashland')
self.p2.save()
self.r = Restaurant(place=self.p1, serves_hot_dogs=True, serves_pizza=False)
self.r.save()
def test_getter(self):
# A Restaurant can access its place.
self.assertEqual(repr(self.r.place), '<Place: Demon Dogs the place>')
# A Place can access its restaurant, if available.
self.assertEqual(repr(self.p1.restaurant), '<Restaurant: Demon Dogs the restaurant>')
# p2 doesn't have an associated restaurant.
self.assertRaises(Restaurant.DoesNotExist, getattr, self.p2, 'restaurant')
def test_setter(self):
# Set the place using assignment notation. Because place is the primary
# key on Restaurant, the save will create a new restaurant
self.r.place = self.p2
self.r.save()
self.assertEqual(repr(self.p2.restaurant), '<Restaurant: Ace Hardware the restaurant>')
self.assertEqual(repr(self.r.place), '<Place: Ace Hardware the place>')
self.assertEqual(self.p2.pk, self.r.pk)
# Set the place back again, using assignment in the reverse direction.
self.p1.restaurant = self.r
self.assertEqual(repr(self.p1.restaurant), '<Restaurant: Demon Dogs the restaurant>')
r = Restaurant.objects.get(pk=self.p1.id)
self.assertEqual(repr(r.place), '<Place: Demon Dogs the place>')
def test_manager_all(self):
# Restaurant.objects.all() just returns the Restaurants, not the Places.
self.assertQuerysetEqual(Restaurant.objects.all(), [
'<Restaurant: Demon Dogs the restaurant>',
])
# Place.objects.all() returns all Places, regardless of whether they
# have Restaurants.
self.assertQuerysetEqual(Place.objects.order_by('name'), [
'<Place: Ace Hardware the place>',
'<Place: Demon Dogs the place>',
])
def test_manager_get(self):
def assert_get_restaurant(**params):
self.assertEqual(repr(Restaurant.objects.get(**params)),
'<Restaurant: Demon Dogs the restaurant>')
assert_get_restaurant(place__id__exact=self.p1.pk)
assert_get_restaurant(place__id=self.p1.pk)
assert_get_restaurant(place__exact=self.p1.pk)
assert_get_restaurant(place__exact=self.p1)
assert_get_restaurant(place=self.p1.pk)
assert_get_restaurant(place=self.p1)
assert_get_restaurant(pk=self.p1.pk)
assert_get_restaurant(place__pk__exact=self.p1.pk)
assert_get_restaurant(place__pk=self.p1.pk)
assert_get_restaurant(place__name__startswith="Demon")
def assert_get_place(**params):
self.assertEqual(repr(Place.objects.get(**params)),
'<Place: Demon Dogs the place>')
assert_get_place(restaurant__place__exact=self.p1.pk)
assert_get_place(restaurant__place__exact=self.p1)
assert_get_place(restaurant__place__pk=self.p1.pk)
assert_get_place(restaurant__exact=self.p1.pk)
assert_get_place(restaurant__exact=self.r)
assert_get_place(restaurant__pk=self.p1.pk)
assert_get_place(restaurant=self.p1.pk)
assert_get_place(restaurant=self.r)
assert_get_place(id__exact=self.p1.pk)
assert_get_place(pk=self.p1.pk)
def test_foreign_key(self):
# Add a Waiter to the Restaurant.
w = self.r.waiter_set.create(name='Joe')
w.save()
self.assertEqual(repr(w), '<Waiter: Joe the waiter at Demon Dogs the restaurant>')
# Query the waiters
def assert_filter_waiters(**params):
self.assertQuerysetEqual(Waiter.objects.filter(**params), [
'<Waiter: Joe the waiter at Demon Dogs the restaurant>'
])
assert_filter_waiters(restaurant__place__exact=self.p1.pk)
assert_filter_waiters(restaurant__place__exact=self.p1)
assert_filter_waiters(restaurant__place__pk=self.p1.pk)
assert_filter_waiters(restaurant__exact=self.p1.pk)
assert_filter_waiters(restaurant__exact=self.p1)
assert_filter_waiters(restaurant__pk=self.p1.pk)
assert_filter_waiters(restaurant=self.p1.pk)
assert_filter_waiters(restaurant=self.r)
assert_filter_waiters(id__exact=self.p1.pk)
assert_filter_waiters(pk=self.p1.pk)
# Delete the restaurant; the waiter should also be removed
r = Restaurant.objects.get(pk=self.p1.pk)
r.delete()
self.assertEqual(Waiter.objects.count(), 0)
def test_multiple_o2o(self):
# One-to-one fields still work if you create your own primary key
o1 = ManualPrimaryKey(primary_key="abc123", name="primary")
o1.save()
o2 = RelatedModel(link=o1, name="secondary")
o2.save()
# You can have multiple one-to-one fields on a model, too.
x1 = MultiModel(link1=self.p1, link2=o1, name="x1")
x1.save()
self.assertEqual(repr(o1.multimodel), '<MultiModel: Multimodel x1>')
# This will fail because each one-to-one field must be unique (and
# link2=o1 was used for x1, above).
sid = transaction.savepoint()
mm = MultiModel(link1=self.p2, link2=o1, name="x1")
self.assertRaises(IntegrityError, mm.save)
transaction.savepoint_rollback(sid)
def get(self, userid):
parser = reqparse.RequestParser()
parser.add_argument(
'lon',
required=True,
type=float,
help='Longitude(degrees) format example: lon=23.23')
parser.add_argument('lat',
required=True,
type=float,
help='Latitude(degrees) format example: lat=23.23')
parser.add_argument('location',
required=True,
type=str,
help="location='San Francisco'")
args = parser.parse_args()
data = None
#make call to yelp here
try:
user = User.getUserById(db, userid)
print("userid:", userid)
if user == None:
return {"message": "invalid userid"}, 400
offset = user.getOffset()
data = yelp.search(args['lat'], args['lon'], offset)
restaurants = data['businesses']
user.incrOffset(len(restaurants))
User.save(db, user)
for restaurant in restaurants:
#parse yelp metadata
name = restaurant['name']
location = restaurant['location']
lat = float(location['coordinate']['latitude'])
lon = float(location['coordinate']['longitude'])
pos = (lat, lon)
if Restaurant.checkIfExists(db, pos):
continue
yelp_categories = restaurant['categories']
categories = []
for group in yelp_categories:
categories.append(
group[0]
) #yelp format is [["Sam", "sam"], ["Blah","blah"]]
address = location['address']
city = location['city']
zip_code = location['postal_code']
yelp_rating = restaurant['rating']
yelp_count = restaurant['review_count']
img_url = restaurant['image_url']
restid = db.get('restcount', 0) + 1
db['restcount'] = restid
restObj = Restaurant(name, pos, restid, categories, yelp_count,
yelp_rating, address, city, zip_code,
img_url)
Restaurant.save(db, restObj)
except Exception as e:
print traceback.format_exc()
return data
