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 get(self):
context = {
'karma_ranking': Restaurant.gql('WHERE group=:1 ORDER BY karma DESC LIMIT 10', self.currentgroup),
'lunchcount_ranking': Restaurant.gql('WHERE group=:1 ORDER BY lunchcount DESC LIMIT 10', self.currentgroup),
'best_user': self.currentgroup.get_best_users(),
'biggest_eater': self.currentgroup.get_biggest_users()
}
self.render('stats', context)
def post(self):
name = cgi.escape(self.request.get('name'))
name = name.capitalize()
if name == '':
self.error(400)
return
restaurant = Restaurant.gql("WHERE name = :1 AND group = :2", name, self.currentgroup).get()
if restaurant == None:
restaurant = Restaurant(name=name, group=self.currentgroup)
restaurant.put()
else:
logging.info("restaurant '%s' already exists, skipping" % name)
self.get()
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 render_search():
create_whoosh_dir()
rest_ix = get_restaurant_index()
loc_ix = get_location_index()
cat_ix = get_category_index()
restSearchableFields = ["name","phonenum"]
locSearchableFields = ["address","neighborhood", "zipcode"]
catSearchableFields = ["name"]
restDataList = []
locDataList = []
catDataList = []
if request.method == 'POST':
search_query = request.form['search']
restDataList = search_results(rest_ix, search_query, restSearchableFields)
locDataList = search_results(loc_ix, search_query, locSearchableFields)
catDataList = search_results(cat_ix, search_query, catSearchableFields)
constructRelatedModels(restDataList, locDataList, catDataList)
return render_template('search_results.html',
restDataNames=Restaurant.getDataNames() + ["context"],
restDataList=restDataList,
locDataNames=Location.getDataNames() + ["context"],
locDataList=locDataList,
catDataNames=Category.getDataNames() + ["context"],
catDataList=catDataList)
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 DocFromModels(rest_id, menu_id):
# try:
rest = Restaurant.get_by_id(rest_id)
menu = Menu.get_by_id(menu_id)
ui_profile = UIProfile.get_by_menu(menu)
menuitems = MenuItem.get_by_menu(menu)
grab_vars = lambda item: deepcopy(vars(item)["_entity"])
obj = {}
obj["menu_id"] = menu.menu_id
obj["restaurant_id"] = rest.restaurant_id
obj["restaurant_name"] = rest.name
obj["menu_name"] = menu.name
obj["ui_profile"] = grab_vars(ui_profile)
obj["ui_profile"]["menu"] = "null"
obj["menuitems"] = {}
for menuitem in menuitems:
category = menuitem.category
menu_item_dict = grab_vars(menuitem)
menu_item_dict["menu"] = "null"
if obj["menuitems"].has_key(category):
obj["menuitems"][category].append(menu_item_dict)
else:
obj["menuitems"][category] = [menu_item_dict]
return json.dumps(obj)
def verifyMessage(request):
# message, secret_key, timestamp, request_hash
message = request.get("message")
timestamp = request.get("timestamp")
request_hash = request.get("message_hash")
secret_key = Restaurant.get_by_id(request.get("restaurant_id")).secret_key
message_hash = hashlib.sha1(message + secret_key + timestamp).hexdigest()
return message_hash == request_hash
def create_restaurant():
r = request.json
if not r or 'title' not in r or type(r['title']) is not unicode or len(r['title'].strip()) < 2:
abort(400)
title = r['title'].strip().lower()
if Restaurant.query.filter_by(title = title).count():
abort(409)
else:
restaurant = Restaurant(**r)
db.session.add(restaurant)
db.session.commit()
db.session.refresh(restaurant)
sock.emit('append', {'uri': '/api/restaurants/%d' % restaurant.id}, namespace='/test')
return json.dumps(restaurant.to_dict(), ensure_ascii = False)
def render_restaurant():
tableDataDict = getTableDataDict("Restaurants","restaurant", Restaurant)
restDataDictList = getDataDictList(getModels(Restaurant, tableDataDict['offset'],
tableDataDict['sortby'], tableDataDict['direction']))
return render_template('template_db.html',
dataNames=Restaurant.getDataNames(),
dataList=restDataDictList,
**tableDataDict
)
def post(self):
if AUTH_ENABLED and not verifyMessage(self.request):
self.response.out.write("AUTH FAILED")
return
restaurant_id = self.request.get("restaurant_id")
self.response.headers["Access-Control-Allow-Origin"] = "*"
if Restaurant.delete_by_id(restaurant_id):
self.response.out.write("Menu Successfully Deleted")
else:
self.response.out.write("ERROR: Could not delete")
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")
def restaurant_feed():
feed = AtomFeed('Recent Restaurants',
feed_url=request.url, url=request.url_root)
restaurants = Restaurant.newest(10)
for restaurant in restaurants:
feed.add(restaurant.name, unicode(restaurant.menu_items_str),
content_type='html',
author=restaurant.user.name,
url=make_external(restaurant.url),
updated=restaurant.last_update,
published=restaurant.published)
return feed.get_response()
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_issue_7276(self):
# Regression test for #7276: calling delete() on a model with
# multi-table inheritance should delete the associated rows from any
# ancestor tables, as well as any descendent objects.
place1 = Place(
name="Guido's House of Pasta",
address='944 W. Fullerton')
place1.save_base(raw=True)
restaurant = Restaurant(
place_ptr=place1,
serves_hot_dogs=True,
serves_pizza=False)
restaurant.save_base(raw=True)
italian_restaurant = ItalianRestaurant(
restaurant_ptr=restaurant,
serves_gnocchi=True)
italian_restaurant.save_base(raw=True)
ident = ItalianRestaurant.objects.all()[0].id
self.assertEqual(Place.objects.get(pk=ident), place1)
xx = Restaurant.objects.create(
name='a',
address='xx',
serves_hot_dogs=True,
serves_pizza=False)
# This should delete both Restuarants, plus the related places, plus
# the ItalianRestaurant.
Restaurant.objects.all().delete()
self.assertRaises(
Place.DoesNotExist,
Place.objects.get,
pk=ident)
self.assertRaises(
ItalianRestaurant.DoesNotExist,
ItalianRestaurant.objects.get,
pk=ident)
def get(self):
if AUTH_ENABLED and not verifyMessage(self.request):
self.response.out.write("AUTH FAILED")
return
rest_id = self.request.get("restaurant_id")
rest = Restaurant.get_by_id(rest_id)
if not rest:
self.response.out.write("Restaurant does not exist")
return
doc = self.request.get("doc")
doc_obj = json.loads(doc)
self.response.headers["Access-Control-Allow-Origin"] = "*"
self.response.out.write(template.render("templates/index.html", doc_obj))
def render_category_id(category_id=None):
catModel = Category.query.get_or_404(category_id)
imgList = [restModel.imageurl for restModel in catModel.restlist][:5]
while len(imgList) < 5:
imgList = imgList + [url for url in imgList]
imgList = imgList[:5]
relatedRestModels = getDataDictList(catModel.restlist)
return render_template('category.html',
catModel = catModel,
restAttrs = Restaurant.getDataNames(),
imgList = imgList,
restListModels = dumps(relatedRestModels))
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 get(self):
if self.currentuser.lastposted == None:
self.redirect('/profile')
return
group = self.currentgroup
context = { 'ask_to_rate' : can_vote(self.currentuser, self.currentgroup),
'active_crew': get_active_crew(group),
'dead_crew': get_dead_crew(group),
'suggestions': Suggestion.get_todays(group),
'restaurants': Restaurant.get_for_group(group) }
self.render('home', context)
def post(self):
auth_code = self.request.get("auth_code")
if auth_code != PASSCODE and AUTH_ENABLED:
self.response.out.write("AUTH FAILED")
return
rest = Restaurant.create(self.request.get("name"))
return_obj = {"secret_key": rest.secret_key, "restaurant_id": rest.restaurant_id}
menu = Menu.create("menu", rest)
uiProfile = UIProfile.create(menu)
menu_item_1 = MenuItem.create("Starter Item 1", menu, 10.00, "Appy", "This is a sample menu Item")
menu_item_2 = MenuItem.create("Starter Item 2", menu, 11.00, "Drink", "This is a sample menu Item")
self.response.headers["Access-Control-Allow-Origin"] = "*"
self.response.out.write(json.dumps(return_obj))
def ModelsFromDoc(jsonString, rest_id):
try:
obj = json.loads(jsonString)
profile_id = obj["ui_profile"]["profile_id"]
# Create or Update Rest
rest = Restaurant.get_by_id(rest_id)
rest.name = obj["restaurant_name"]
# Create or Update Menu
menu = Menu.get_menus_by_rest_id(rest_id)[0]
menu.name = obj["menu_name"]
menu.resturant = rest
# Create or Update UI Profile
UIProfile.delete_by_menu(menu)
ui_profile = UIProfile.create(menu)
ui_profile.template = obj["ui_profile"]["template"]
ui_profile.color = obj["ui_profile"]["color"]
ui_profile.font = obj["ui_profile"]["font"]
ui_profile.logo_url = obj["ui_profile"]["logo_url"]
# logging.info(str(obj))
# Create or Update menuitems
MenuItem.delete_by_menu(menu)
menu_items_dict = obj["menuitems"]
logging.info(type(menu_items_dict))
for category in menu_items_dict.keys():
category_list = menu_items_dict[category]
for menu_item_dict in category_list:
menuitem = MenuItem.create(
menu_item_dict["name"],
menu,
menu_item_dict["price"],
category,
menu_item_dict["image"],
menu_item_dict["description"],
)
menuitem.put()
ui_profile.put()
menu.put()
rest.put()
return True
except:
return False
def edit_menu_item(restaurant_id, menu_item_id):
restaurant = Restaurant.get_by_id(restaurant_id)
menu_item = MenuItem.get_by_id(menu_item_id)
if request.method == 'POST':
menu_item_name = request.form['menu_item_name']
menu_item_description = request.form['menu_item_description']
menu_item_price = request.form['menu_item_price']
menu_item.update(name=menu_item_name,
description=menu_item_description,
price=menu_item_price)
flash('Menu item edited')
return redirect(
url_for('single_restaurant', restaurant_id=restaurant_id))
else:
return render_template('edit-menu-item.html',
restaurant=restaurant,
menu_item=menu_item)
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 createRestaurant(location, mealType):
print 'inside createRestaurant'
try:
restaurant_info = findARestaurant(location, mealType)
if restaurant_info != 'No Restaurants Found':
print 'restaurant info: %s' % unicode(restaurant_info)
newRestaurant = Restaurant(
restaurant_name = unicode(restaurant_info['name']),
restaurant_address = unicode(restaurant_info['address']),
restaurant_image = restaurant_info['image']
)
session.add(newRestaurant)
session.commit()
return jsonify(restaurant = newRestaurant.serialize)
else:
return jsonify({'error':'No Restaurants returned for %s in %s' % (mealType, location)})
except:
return jsonify({'error':'Cannot retrive Restaurants for %s in %s' % (mealType, location)})
def test_restaurant_address_and_name_nonempty(self):
''' Tries to update restaurant information using a non-empty
restaurant name and address.'''
restaurant = Restaurant(name="test name",
address="test address",
uid=10)
db.session.add(restaurant)
db.session.commit()
errmsg = rhelper.update_restaurant_information(restaurant, "new name",
"new address")
self.assertEqual(errmsg, [])
updatedRestaurant = Restaurant.query.filter(
Restaurant.rid == 1).first()
self.assertEqual(updatedRestaurant.name, "new name")
self.assertEqual(updatedRestaurant.address, "new address")
self.assertEqual(updatedRestaurant.uid, 10)
def test_restaurant_name_empty(self):
''' Tries to update restaurant information using an empty
restaurant name. '''
restaurant = Restaurant(name="test name",
address="test address",
uid=10)
db.session.add(restaurant)
db.session.commit()
errmsg = rhelper.update_restaurant_information(restaurant, "",
"new address")
self.assertEqual(errmsg, ["The restaurant's name cannot be empty."])
updatedRestaurant = Restaurant.query.filter(
Restaurant.rid == 1).first()
self.assertEqual(updatedRestaurant.name, "test name")
self.assertEqual(updatedRestaurant.address, "test address")
self.assertEqual(updatedRestaurant.uid, 10)
def test_owner_found(self):
"""
Test finding an rid by given a valid uid. Expect output to match correct data.
"""
restaurant = Restaurant(rid=17465,
name="KFC",
address="1265 Military trail",
uid=34)
user = User(uid=34,
name="joe",
email="*****@*****.**",
password="******",
type=1)
db.session.add(restaurant)
db.session.add(user)
db.session.commit()
rid = rhelper.get_rid(34)
self.assertEqual(rid, 17465)
def createARestaurant(location, mealtype):
# Here I use my api findARestaurant to return the first restaurant
# it will return name, address and image
indication = find(mealtype, location)
if type(indication) is not dict:
return jsonify("no restaurant found")
else:
loc = ", ".join(indication["address"])
# store the restaurant in the database
restaurant = Restaurant(name=indication["name"],
address=loc,
image=indication["image"])
session.add(restaurant)
session.commit()
# returns the restaurant for the user
return jsonify(Restaurant=restaurant.serialize)
def insert_new_restaurant(rname, address, uid):
"""
Inserts restaurant into restaurant table.
Args:
rname: The name given to the resturant. A string with max 64 characters.
address: The address given to the resturant. A string with max 64
characters.
uid: The user ID that corressponds to the a owner. A positive integer.
Returns:
the resturant ID that corressponds with the newly inserted restaurant.
The resturant ID is always a positive interger.
"""
restaurant = Restaurant(name=rname, address=address, uid=uid)
db.session.add(restaurant)
db.session.commit()
return restaurant.rid
def all_restaurants_handler():
if request.method == 'GET':
restaurants = session.query(Restaurant).all()
return jsonify(restaurants=[i.serialize for i in restaurants])
elif request.method == 'POST':
location = request.args.get('location', '')
mealType = request.args.get('mealType', '')
restaurant_info = findARestaurant(mealType, location)
if restaurant_info != "No Restaurants Found":
restaurant = Restaurant(restaurant_name=unicode(restaurant_info['name']),
restaurant_address=unicode(restaurant_info['address']),
restaurant_image=restaurant_info['image'])
session.add(restaurant)
session.commit()
return jsonify(restaurant=restaurant.serialize)
else:
return jsonify({"error": "No Restaurants Found for %s in %s" % (mealType, location)})
def all_restaurants_handler():
if request.method == 'GET':
# RETURN ALL RESTAURANTS IN DATABASE
restaurants = session.query(Restaurant).all()
return jsonify(restaurants = [i.serialize for i in restaurants])
elif request.method == 'POST':
# MAKE A NEW RESTAURANT AND STORE IT IN DATABASE
location = request.args.get('location', '')
mealType = request.args.get('mealType', '')
restaurant_info = findARestaurant(mealType, location)
if restaurant_info != "No Restaurants Found":
restaurant = Restaurant(restaurant_name = str(restaurant_info['name']), restaurant_address = str(restaurant_info['address']), restaurant_image = restaurant_info['image'])
session.add(restaurant)
session.commit()
return jsonify(restaurant = restaurant.serialize)
else:
return jsonify({"error":"No Restaurants Found for %s in %s" % (mealType, location)})
def all_restaurants_handler():
if request.method == 'GET':
restaurants = session.query(Restaurant).all()
return jsonify(restaurants=[i.serialize for i in restaurants])
elif request.method == 'POST':
location = request.args.get('location')
mealType = request.args.get('mealType')
restaurant = findARestaurant(mealType, location)
if restaurant != 'No Restaurants Found':
newItem = Restaurant(
restaurant_name=restaurant['name'], restaurant_address=restaurant['address'], restaurant_image=restaurant['image'])
session.add(newItem)
session.commit()
return jsonify(restaurant=newItem.serialize)
else:
return jsonify(
{"error": "No Restaurants Found for {} in {}".format(mealType, location)})
def all_restaurants_handler():
#YOUR CODE HERE
if request.method == 'GET':
# Return all restaurants in database
restaurants = session.query(Restaurant).all()
return jsonify(restaurants = [restaurant.serialize for restaurant in restaurants])
elif request.method == 'POST':
# Make a new restaurant and store it in database
location = request.args.get('location') # or ('location', '')
mealType = request.args.get('mealType')
restaurantInfo = findARestaurant(mealType, location)
if restaurantInfo != "No Restaurants Found":
restaurant = Restaurant(restaurant_name = unicode(restaurantInfo['name']), restaurant_address = unicode(restaurantInfo['address']), restaurant_image = unicode(restaurantInfo['image']))
session.add(restaurant)
session.commit()
return jsonify(restaurant = restaurant.serialize)
else:
return jsonify({'Error':'No Restaurant Found for %s around %s'} % (mealType, location))
def all_restaurants_handler():
#YOUR CODE HERE
if request.method == 'POST':
#
location = request.args.get('location')
mealType = request.args.get('mealType')
RestaurantJSON = findARestaurant(mealType, location)
newRestaurant = Restaurant(
restaurant_name=RestaurantJSON['name'],
restaurant_address=RestaurantJSON['address'],
restaurant_image=RestaurantJSON['image'])
session.add(newRestaurant)
session.commit()
return jsonify(Restaurant=newRestaurant.serialize)
if request.method == 'GET':
#RETURN ALL RESTAURANTS
allRestaurants = session.query(Restaurant).all()
return jsonify(Restaurant=[i.serialize for i in allRestaurants])
def newRestaurant():
"""
Create a new restaurant.
:return:
on GET: Render new restaurant form template.
on POST: Redirect to the restaurants page if the create request has been succeeded.
"""
if request.method == 'POST':
restaurant = Restaurant(name=request.form['name'],
description=request.form['description'],
telephone=request.form['telephone'],
user_id=login_session['user_id'])
session.add(restaurant)
session.commit()
flash('New restaurant %s successfully created!' % restaurant.name)
return redirect(url_for('showHome'))
else:
return render_template('newRestaurant.html')
def get(self):
user = users.get_current_user()
restaurant = Restaurant.query(Restaurant.user == user.email()).fetch()
if restaurant:
log_url = users.create_logout_url('/')
restaurant = restaurant[0]
tables = Table.query(Table.restaurant_id == restaurant.key).order(
Table.time_filled).fetch()
template_vars = {
"tables": tables,
"restaurant": restaurant,
"log_url": log_url,
}
tables_template = jinja_current_directory.get_template(
"templates/tables.html")
self.response.write(tables_template.render(template_vars))
else:
self.response.write(users.create_logout_url('/'))
def read(opfile):
reader = csv.reader(opfile)
included_cols = [0, 1, 2, 3]
for row in reader:
content = list(row[i] for i in included_cols)
url = main_api + 'search?q=' + content[1]
data = returnresponse(url)
for r in range(0, len(data["restaurants"])):
var = data["restaurants"][r]["restaurant"]
if var["location"]["locality"].find(content[2]) != -1:
try:
Restaurant.nodes.get(rid=var["id"])
except Restaurant.DoesNotExist:
Restaurant(rid=var["id"], name=var["name"], rating=var["user_rating"]["aggregate_rating"],
ratings_count=var["user_rating"]["votes"], avg_cost=var["average_cost_for_two"],
url=var["url"], has_online_delivery=var["has_online_delivery"],
has_table_booking=var["has_table_booking"]).save()
rest = Restaurant.nodes.get(rid=var["id"])
cuisines = var["cuisines"].split(',')
for j in range(0, len(cuisines)):
cuisine_node = Cuisine.nodes.get(name=cuisines[j].strip())
rest.SERVES.connect(cuisine_node)
var_loc = var["location"]
try:
Location.nodes.get(locality=var_loc["locality"])
except Location.DoesNotExist:
Location(locality=var_loc["locality"]).save()
loc = Location.nodes.get(locality=var_loc["locality"])
rest.IN.connect(loc, {'addr': var_loc['address'], 'lat': var_loc['latitude'],
'long': var_loc['longitude'], \
'zipcode': var_loc['zipcode']})
rest = Restaurant.nodes.get(rid=var["id"])
if content[0] != " ":
try:
User.nodes.get(name=content[0])
print("hello")
except User.DoesNotExist:
User(name=content[0]).save()
u = User.nodes.get(name=content[0])
u.RATED.connect(rest, {'rating': content[3]})
break
def test_no_such_rid_addr(self):
"""
Test that the coupon's related rid is not exist, the method should return
"Not Found". Expect an error message.
"""
res = Restaurant(name="resName", address="Address", uid=404)
db.session.add(res)
db.session.commit()
coupon = Coupon(rid=900,
name="coupon_testing",
points=10,
description="description",
level=88,
expiration=None,
begin=None,
deleted=0)
db.session.add(coupon)
db.session.commit()
raddr = chelper.find_res_addr_of_coupon_by_cid(coupon.cid)
self.assertEqual(raddr, "Not Found")
def all_restaurants_handler():
if request.method == 'GET':
restaurants = session.query(Restaurant).all()
return jsonify(restaurants=[i.serialize for i in restaurants])
elif request.method == 'POST':
mealType = request.args.get('mealType')
location = request.args.get('location')
found = findARestaurant(mealType, location)
newRestaurant = Restaurant(restaurant_name=unicode(found['name']),
restaurant_address=unicode(
found['address']),
restaurant_image=found['image'])
session.add(newRestaurant)
session.commit()
return jsonify(newRestaurant=newRestaurant.serialize)
def test_normal_resaddr_valid_cid(self):
"""
Test if we can find the correct res addr by given the cid of the coupon
as we expected. Expect output to match correct data.
"""
res = Restaurant(name="res", address="Address", uid=505)
db.session.add(res)
db.session.commit()
coupon = Coupon(rid=res.rid,
name="coupon_testing",
points=10,
description="description",
level=56,
expiration=None,
begin=None,
deleted=0)
db.session.add(coupon)
db.session.commit()
raddr = chelper.find_res_addr_of_coupon_by_cid(coupon.cid)
self.assertEqual(raddr, "Address")
def post(self):
user = users.get_current_user()
Restaurant(
name=self.request.get('name_r'),
phone=self.request.get('phone_r'),
street_address=self.request.get('street'),
city=self.request.get('city'),
state=self.request.get('state'),
zip_code=self.request.get('zip'),
user=user.email(),
).put()
Table(
description=self.request.get('table_description'),
max=self.request.get('table_size_max'),
min=self.request.get('table_size_min'),
#restaurant_id = self.request.get(),
full=False,
time_filled=datetime.datetime.now(),
).put()
def get(self):
user = users.get_current_user()
restaurant = Restaurant.query(Restaurant.user == user.email()).fetch()
if restaurant:
log_url = users.create_logout_url('/')
restaurant = restaurant[0]
waits = Wait.query(
Wait.restaurant_key == restaurant.key).order().fetch()
template_vars = {
"waits": waits,
"restaurant": restaurant,
"twilio_account_sid": SECRETS["twilio_account_sid"],
"twilio_auth_token": SECRETS["twilio_auth_token"],
"log_url": log_url,
}
activeq_template = jinja_current_directory.get_template(
"templates/active_q.html")
self.response.write(activeq_template.render(template_vars))
else:
self.response.write(users.create_logout_url('/'))
def get(self):
if AUTH_ENABLED and not verifyMessage(self.request):
self.response.out.write("AUTH FAILED")
return
rest_id = self.request.get("restaurant_id")
rest = Restaurant.get_by_id(rest_id)
if not rest:
self.response.out.write("Restaurant does not exist")
return
menu_id = Menu.get_menus_by_rest_id(rest_id)[0].menu_id
doc = DocFromModels(rest_id, menu_id)
logging.info(doc)
doc_obj = json.loads(doc)
self.response.headers.add_header("Access-Control-Allow-Origin", "*")
self.response.headers.add_header(
"Access-Control-Allow-Headers",
"X-Requested-With, Content-Type, Access-Control-Allow-Headers Origin, Access-Control-Allow-Origin, Access-Control-All",
)
self.response.out.write(template.render("templates/index.html", doc_obj))
def login():
errormsg = ''
if request.method == 'POST':
usrnm = request.form['username'].strip()
pwd = request.form['password']
from ecarte.admin.models import User
u = User.find(usrnm)
if not u:
errormsg = 'Invalid user name.'
else:
if u.check_password(pwd):
login_user(u, remember=True)
# TODO: if not admin and has only one r, redirect to the edit page
url = 'admin'
if not u.is_admin:
rlist = list(Restaurant.list_names_and_addresses(u.id))
if len(rlist) == 1:
url = 'admin/%s' % rlist[0]['_id']
return redirect(request.args.get('next') or url)
else:
errormsg = 'Invalid password.'
return render_template('admin/login.html', errormsg=errormsg)
def all_restaurants_handler():
if request.method == 'GET':
#Call the method to Get all of the restaurants
restaurants = session.query(Restaurant).all()
return jsonify(restaurants=[i.serialize for i in restaurants])
elif request.method == 'POST':
#Call the method to make a new restaurant
print "Make a new restaurant from foursquare and store it into database"
location = request.args.get('location', '')
mealType = request.args.get('mealType', '')
restaurant_info = findARestaurant(location, mealType)
if restaurant_info != "No Restaurants Found":
restaurant = Restaurant(
restaurant_name = unicode(restaurant_info['name']),
restaurant_address = unicode(restaurant_info['address']),
restaurant_image = restaurant_info['image'])
session.add(restaurant)
session.commit()
return jsonify(restaurant = restaurant.serialize)
else:
return jsonify({"error":"No Restaurants Found for %s in %s" % (mealType, location)})
def get(self):
user = users.get_current_user()
#if statement that checks if user is logged in via google
if user:
log_url = users.create_logout_url('/')
#check if user is in Restaurant Datastore already/is a returning user
user_email = user.email()
rest_query = Restaurant.query(
Restaurant.user == user_email).fetch(1)
#if user email is in Restaurant Datastore go to home page/ else send to new restaurant handler
if rest_query != []:
self.redirect('/tables')
else:
self.redirect('/new_rest')
#if user not logged into google, generates login
else:
log_url = users.create_login_url('/')
#renders login2 html page with link to login url for unlogged in users
login_template = jinja_current_directory.get_template(
"templates/login2.html")
self.response.write(login_template.render({'log_url': log_url}))
def all_restaurants_handler():
if request.method == 'GET':
# RETURN ALL RESTAURANTS IN DATABASE
restaurants = session.query(Restaurant).all()
return jsonify(restaurants=[i.serialize for i in restaurants])
elif request.method == 'POST':
# MAKE A NEW RESTAURANT AND STORE IT IN DATABASE
location = request.form.get('location')
food = request.form.get('food')
latitude, longitude = get_latitude_longitude_location(location)
restaurant_info = get_restaurants(latitude, longitude, food)
if restaurant_info != 'No Restaurants Found':
restaurant = Restaurant(restaurant_id = restaurant_info['restaurant_id'], name = restaurant_info['name'], \
location = restaurant_info['location'], food = restaurant_info['food'])
session.add(restaurant)
session.commit()
return jsonify(restaurant=restaurant.serialize)
else:
return jsonify(
{'error': f'No Restaurants Found for {food} in {location}'})
def _save_helper(updatefn, **kwargs):
rid = request.form.get('rid', '').strip()
new = False
r = None
if rid:
r = Restaurant.get(rid)
if not r:
abort(404)
else:
if kwargs.get('create_new', False):
r, new = {}, True
else:
abort(404)
ok, data = updatefn(r, request.form)
if ok:
data.update(status=STATUS_OK, rid=str(r['_id']))
if new:
data['redirect'] = True
if 'success_msg' in kwargs:
data['success_msg'] = kwargs['success_msg']
else:
data.update(status=STATUS_ERROR)
return data
def test_to_json_1(self):
a = Restaurant(
restaurant_name="sample",
rating=4.5,
image_url="sample",
price="sample",
review_count=1,
city_name="sample",
state_name="sample",
transactions="sample",
categories="sample",
address="sample",
city_state_name="sample",
)
res = to_json(a, Restaurant)
temp = json.loads(res)
self.assertEqual(temp["restaurant_name"], "sample")
self.assertEqual(temp["rating"], 4.5)
self.assertEqual(temp["price"], "sample")
self.assertEqual(temp["review_count"], 1)
self.assertEqual(temp["address"], "sample")
def post(self):
if AUTH_ENABLED and not verifyMessage(self.request):
self.response.out.write("AUTH FAILED")
return
rest_id = self.request.get("restaurant_id")
menu_name = self.request.get("menu_name")
rest = Restaurant.get_by_id(rest_id)
if not rest:
self.response.out.write("Invalid restaurant_id")
return
if Menu.get_menus_by_rest_id(rest_id):
self.resonse.out.write("Cant create another menu for this restaurant. It already has one")
return
menu = Menu.create(menu_name, rest)
uiProfile = UIProfile.create(menu)
menu_item_1 = MenuItem.create("Starter Item 1", menu, 10.00, "Appy", "This is a sample menu Item")
menu_item_2 = MenuItem.create("Starter Item 2", menu, 11.00, "Drink", "This is a sample menu Item")
self.response.headers.add_header("Access-Control-Allow-Origin", "*")
self.response.headers.add_header("Access-Control-Allow-Headers", "X-Requested-With")
self.response.out.write(DocFromModels(rest_id, menu.menu_id))
def get(self):
if is_morning():
day = datetime.now() - timedelta(1)
day_title = "yesterday"
else:
day = datetime.now()
day_title = "today"
suggestions = Suggestion.get_for_day(day, self.currentgroup)
restaurants = [ s.restaurant for s in suggestions ]
res_keys = [ r.key() for r in restaurants ]
other_restaurants = []
all_restaurants = Restaurant.gql("WHERE group=:1 ORDER BY name", self.currentgroup)
for res in all_restaurants:
if res.key() not in res_keys:
other_restaurants.append(res)
context = { 'day': day.toordinal(),
'day_title': day_title,
'restaurants': restaurants,
'other_restaurants': other_restaurants }
self.render('rate', context)
def all_restaurants_handler():
if request.method == 'POST':
# expects params
# location, mealType
location = request.form.get('location','55108')
mealType = request.form.get('mealType','Pizza')
print location,mealType
# find a restaurant
located_restaurant = findARestaurant(mealType, location)
name = located_restaurant['name']
address = located_restaurant['address']
image = located_restaurant['image']
# insert into db
new_restaurant = Restaurant(restaurant_name=name,restaurant_address=address,restaurant_image=image)
try:
session.add(new_restaurant)
session.commit()
except exc.DatabaseError as e:
print("Problem commiting the update in {0}".format(new_restaurant.name))
print("Error message:".format(e.message))
return jsonify(new_restaurant.serialize)
elif request.method == 'GET':
# Return all Restaurants
restaurants = session.query(Restaurant)
restaurants_list = []
# add serialized json to array
for res in restaurants:
restaurants_list.append(res.serialize)
# send back a restaurants json object, with it's value the array of json restaurants
return_obj={}
return_obj['restaurants']=restaurants_list
return jsonify(return_obj)
def restaurants(request):
#connect to our local mongodb
db = Connection('localhost', 27017)
#get a connection to our database
dbconn = db.restaurants
restaurantCollection = dbconn['restaurants']
if request.method == 'GET':
#get our collection
restaurants = []
for r in restaurantCollection.find():
restaurant = Restaurant(r["_id"], r["name"], r["address"])
restaurants.append(restaurant)
serializedList = RestaurantSerializer(restaurants, many=True)
return Response(serializedList.data)
elif request.method == 'POST':
#get data from the request and insert the record
name = request.POST["name"]
address = request.POST["address"]
try:
restaurantCollection.insert({"name": name, "address": address})
except:
return Response({"ok": "false"})
return Response({"ok": "true"})
def update(r, form):
if not request.files or 'file' not in request.files:
return False, {'file': 'Missing image file.'}
if request.files['file'].content_type != 'image/jpeg':
return False, {'file': 'Only JPEG images are allowed.'}
ret = Restaurant.update_entry_image(r, form)
if ret[0]:
sio = StringIO(request.files['file'].read())
img = Image.open(sio)
# crop to a sqare
w1, w2 = min(img.size[0],
img.size[1]), max(img.size[0], img.size[1])
d = (w2 - w1) / 2
if img.size[0] > img.size[1]:
img = img.crop((d, 0, w2 - d, w1))
elif img.size[1] > img.size[0]:
img = img.crop((0, d, w1, w2 - d))
sz = app.config['ENTRY_PHOTO_SIZE']
img = img.resize((sz, sz), Image.ANTIALIAS)
path = os.path.join(app.config['UPLOAD_DIR'], ret[1])
img.save(path, optimize=True, quality=65)
if ret[0]:
return True, {'image': '/uploaded/' + ret[1]}
return ret
def all_restaurants_handler():
#If GET, return all resturant in Database
if request.method == 'GET':
restaurants = session.query(Restaurant).all()
return jsonify(restaurants=(i.serialize for i in restaurants))
#If POST, make a new resturant and post it in database
elif request.method == 'POST':
location = request.args.get('location', '')
mealType = request.args.get('mealType', '')
restaurant_info = findARestaurant(mealType, location)
if restaurant_info != 'No Restaurants Found':
restaurant = Restaurant(
restaurant_name=unicode(restaurant_info['name']),
restaurant_address=unicode(restaurant_info['address']),
restaurant_image=restaurant_info['image'])
session.add(restaurant)
session.commit()
return jsonify(restaurant=restaurant.serialize)
else:
return ({
"error":
"No Restaurants Found for %s in %s" % (mealType, location)
})
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 test_model_inheritance(self):
# Regression for #7350, #7202
# Check that when you create a Parent object with a specific reference
# to an existent child instance, saving the Parent doesn't duplicate
# the child. This behaviour is only activated during a raw save - it
# is mostly relevant to deserialization, but any sort of CORBA style
# 'narrow()' API would require a similar approach.
# Create a child-parent-grandparent chain
place1 = Place(
name="Guido's House of Pasta",
address='944 W. Fullerton')
place1.save_base(raw=True)
restaurant = Restaurant(
place_ptr=place1,
serves_hot_dogs=True,
serves_pizza=False)
restaurant.save_base(raw=True)
italian_restaurant = ItalianRestaurant(
restaurant_ptr=restaurant,
serves_gnocchi=True)
italian_restaurant.save_base(raw=True)
# Create a child-parent chain with an explicit parent link
place2 = Place(name='Main St', address='111 Main St')
place2.save_base(raw=True)
park = ParkingLot(parent=place2, capacity=100)
park.save_base(raw=True)
# Check that no extra parent objects have been created.
places = list(Place.objects.all())
self.assertEqual(places, [place1, place2])
dicts = list(Restaurant.objects.values('name','serves_hot_dogs'))
self.assertEqual(dicts, [{
'name': u"Guido's House of Pasta",
'serves_hot_dogs': True
}])
dicts = list(ItalianRestaurant.objects.values(
'name','serves_hot_dogs','serves_gnocchi'))
self.assertEqual(dicts, [{
'name': u"Guido's House of Pasta",
'serves_gnocchi': True,
'serves_hot_dogs': True,
}])
dicts = list(ParkingLot.objects.values('name','capacity'))
self.assertEqual(dicts, [{
'capacity': 100,
'name': u'Main St',
}])
# You can also update objects when using a raw save.
place1.name = "Guido's All New House of Pasta"
place1.save_base(raw=True)
restaurant.serves_hot_dogs = False
restaurant.save_base(raw=True)
italian_restaurant.serves_gnocchi = False
italian_restaurant.save_base(raw=True)
place2.name='Derelict lot'
place2.save_base(raw=True)
park.capacity = 50
park.save_base(raw=True)
# No extra parent objects after an update, either.
places = list(Place.objects.all())
self.assertEqual(places, [place2, place1])
self.assertEqual(places[0].name, 'Derelict lot')
self.assertEqual(places[1].name, "Guido's All New House of Pasta")
dicts = list(Restaurant.objects.values('name','serves_hot_dogs'))
self.assertEqual(dicts, [{
'name': u"Guido's All New House of Pasta",
'serves_hot_dogs': False,
}])
dicts = list(ItalianRestaurant.objects.values(
'name', 'serves_hot_dogs', 'serves_gnocchi'))
self.assertEqual(dicts, [{
'name': u"Guido's All New House of Pasta",
'serves_gnocchi': False,
'serves_hot_dogs': False,
}])
dicts = list(ParkingLot.objects.values('name','capacity'))
self.assertEqual(dicts, [{
'capacity': 50,
'name': u'Derelict lot',
}])
# If you try to raw_save a parent attribute onto a child object,
# the attribute will be ignored.
italian_restaurant.name = "Lorenzo's Pasta Hut"
italian_restaurant.save_base(raw=True)
# Note that the name has not changed
# - name is an attribute of Place, not ItalianRestaurant
dicts = list(ItalianRestaurant.objects.values(
'name','serves_hot_dogs','serves_gnocchi'))
self.assertEqual(dicts, [{
'name': u"Guido's All New House of Pasta",
'serves_gnocchi': False,
'serves_hot_dogs': False,
}])
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)
