def get_beer_or_bust(self, beer_id):
beer = Beer.get_by_key_name(beer_id)
if not beer:
beer = Beer.get(beer_id)
if not beer:
raise webob.exc.HTTPNotFound()
return beer
def createMultiple(self):
b = Beer(name="Trough",
organic="Y",
abv=11.2,
ibu=9.0,
brewery_id=None,
style_id=None,
images="http://www.placeholder.com/image.jpg")
b2 = Beer(name="Kipp",
organic="N",
abv=13.1,
ibu=9.1,
brewery_id=None,
style_id=None,
images="http://www.placeholder.com/image.jpg")
db.session.add(b)
db.session.add(b2)
db.session.commit()
rev = Review(date="1996-11-11",
rating=2.2,
comment="Kipp was nasty.",
beer_name=b2.id,
brewery_name=None)
db.session.add(rev)
db.session.commit()
self.assertNotEqual(rev.id, b.id)
self.assertEqual(rev.id, b2.id)
def details(request):
id = request.matchdict["id"]
json_str = bucket.get(id)[2]
beer_dict = json.loads(json_str)
beer = Beer()
for key in beer_dict:
beer.__dict__[key] = beer_dict[key]
return { "model" : beer }
def edit_post(request):
if request.method != "POST":
raise exc.HTTPFound(request.route_url("beers_edit"))
beer = Beer() #would be safer to get the item first
for key in request.params:
beer.__dict__[key] = request.params[key]
bucket.set(beer.name.replace(" ", "_"), 0, 0, json.dumps(beer.__dict__))
raise exc.HTTPFound(request.route_url("beers_details", id=request.params["id"]))
def create_post(request):
if request.method != "POST":
raise exc.HTTPFound(request.route_url("beers_create"))
beer = Beer()
for key in request.params:
beer.__dict__[key] = request.params[key]
bucket.set(beer.brewery_id + "-" + beer.name.replace(" ", "_"), 0, 0, json.dumps(beer.__dict__))
raise exc.HTTPFound(request.route_url("beers_index"))
def post(self):
beer_json = request.get_json()
try:
beer = Beer(name=beer_json['name'], description=beer_json['description'])
session.add(beer)
session.commit()
return (jsonify(beer.to_json()), 201)
except Exception as e:
return ('Missing Parameters', 400)
def test_update_1(self) :
app.config['SQLALCHEMY_DATABASE_URI'] = 'sqlite:///:memory:'
db.drop_all()
db.create_all()
beer1 = Beer(name='Coors Light', description="Taste's like urine.",
is_organic="N", abv=11.1, ibu=30)
db.session.add(beer1)
db.session.commit()
beer1.abv = 1234
db.session.commit()
result = db.session.query(Beer).filter_by(name="Coors Light").first()
self.assertEqual(result.abv, 1234)
def testTriple(self):
brw = Brewery(name="Coor",
city="Austin",
state="Texas",
country="USA",
established=1996,
description="Coor is an easy to drink beer.",
images="https://www.coor.com/image.jpg")
db.session.add(brw)
db.session.commit()
st = Style(name="Amber Ale",
description="Amber Ale is red!",
ibu_min=5.4,
ibu_max=10.2,
abv_min=7.6,
abv_max=15,
srm=21)
db.session.add(st)
db.session.commit()
b = Beer(name="Lite Beer",
organic="N",
abv=9.6,
ibu=14.2,
brewery_id=brw.id,
style_id=st.id,
images="https://www.litebeer.com/litebeer.jpg")
self.assertEqual(b.brewery_id, brw.id)
self.assertEqual(b.style_id, st.id)
self.assertEqual(b.id, 1)
def createReviewFK(self):
b = Beer(name="Miller",
organic="Y",
abv=9.2,
ibu=10.0,
brewery_id=None,
style_id=None,
images="http://www.placeholder.com/image.jpg")
brw = Brewery(
name="BrewMe",
city="Dallas",
state="Texas",
country="USA",
established=2009,
description="BrewMe is a IPA brewer.",
images="https://www.drinkbritain.com/sites/default/files/image.png"
)
db.session.add(b)
db.session.add(brw)
db.session.commit()
rev = Review(date="2009-08-09",
rating=3.2,
comment="Miller was meh.",
beer_name=b.id,
brewery_name=brw.id)
db.session.add(rev)
db.session.commit()
self.assertEqual(rev.beer_name, b.id)
self.assertEqual(rev.brewery_name, brw.id)
def update_beer_menu():
if 'userid' not in session:
return redirect('/login')
adminStatus = Admin.query.get(session['userid'])
if adminStatus:
# ADD
if request.form['update_type'] == 'new':
is_valid = Beer.validate_beer_item(request.form)
if is_valid:
Beer.add_beer_item(request.form)
# MAKE ACTIVE/INACTIVE
elif request.form['update_type'] == 'status':
Beer.update_beer_status(request.form.getlist('beer_id_cb'))
# DELETE
elif request.form['update_type'] == 'delete':
Beer.delete_beer_item(request.form['beer_id'])
# UPDATE
# elif
return render_template('partials/admin_beer.html',
all_beers=Beer.query.order_by(
Beer.brewery_name, Beer.beer_name).all())
return redirect('/')
def initialize_database(app, db):
"""Drop and restore database in a consistent state"""
with app.app_context():
db.drop_all()
db.create_all()
# create beers
db.session.add(Beer('ipa', 10))
db.session.add(Beer('pilsner', 8))
db.session.add(Beer('lager', 8))
db.session.add(Beer('stout', 7))
db.session.commit()
# create donuts
db.session.add(Donut('jelly'))
db.session.add(Donut('glazed'))
db.session.add(Donut('chocolate'))
db.session.add(Donut('bavarian'))
db.session.commit()
def details(request):
id = request.matchdict["id"]
rows = bucket.view("_design/breweries/_view/all_with_beers", stale=False, startkey=json.dumps([id, 0]), endkey=json.dumps([id, u"\uefff", 1]))
json_str = bucket.get(id)[2]
brewery_dict = json.loads(json_str)
brewery = Brewery()
for key in brewery_dict:
brewery.__dict__[key] = brewery_dict[key]
for row in rows[1:len(rows)]:
try:
json_str = bucket.get(row["id"])[2]
beer_dict = json.loads(json_str)
beer = Beer()
for key in beer_dict:
beer.__dict__[key] = beer_dict[key]
beer.id = id
brewery.beers.append(beer)
except Exception, e:
pass
def testBeer(self):
b = Beer(name="Beer1",
organic="Y",
abv=10,
ibu=15,
brewery_id=None,
style_id=None,
images="thisisalink.html")
db.session.add(b)
db.session.commit()
self.assertEqual(b.abv, 15)
self.assertEqual(b.name, "Brewery1")
self.assertEqual(b.id, 1)
def get(self):
full = self.request.GET.get('full', False)
limit = self.request.params.get('limit', 20)
offset = self.request.params.get('offset', 0)
all_beers = Beer.all(keys_only=not full)
total = all_beers.count(read_policy=db.EVENTUAL_CONSISTENCY, deadline=5)
payload = [a_beer for a_beer in all_beers.run(offset=offset, limit=min(limit, total))]
if not payload:
raise webob.exc.HTTPNotFound()
data = {}
if not full:
data['beers'] = [webapp2.uri_for('beer', beer_id=beer.name()) for beer in all_beers]
else:
data['beers'] = [funcs.convert_model(beer) for beer in all_beers]
data['meta'] = funcs.meta_ok()
self.response.write(json.json.dumps(data))
def post(self):
name = self.request.params['name']
description = self.request.params['description']
style = self.request.params['style']
abv = float(self.request.params['abv'])
brewery = self.request.params['brewery']
if Beer.get_by_key_name(name):
raise Conflict(name, webapp2.uri_for('beer', beer_id=name))
new_beer = Beer(key_name=name, style=style, abv=abv, description=description,
brewery=brewery)
if 'vintage' in self.request.params:
new_beer.vintage = int(self.request.get('vintage'))
if 'photo_url' in self.request.params:
new_beer.photo_url = photo_url
new_beer.put()
webapp2.redirect_to('beer', beer_id=name)
def add_beer():
'''
Add and save a beer to the database
'''
# need to pass the brewery dropdown data to the template, because this
# information can change overtime as users add new breweries to the db
brewery_dropdown_data = []
qry = Brewery.query.order_by(Brewery.name)
for brewery in qry:
brewery_dropdown_data.append(brewery.name)
form = BeerForm()
if form.validate_on_submit():
# this section is used to find the correct brewery_id for the selected
# brewery, this is then passed to the beer object to be saved in the db
selected_brewery = request.form.get("brewery", None)
existing_breweries = Brewery.query.order_by(Brewery.name)
for brewery in existing_breweries:
if selected_brewery == brewery.name:
brewery_id = brewery.id
beer = Beer(name=form.name.data,
type=form.type.data,
abv=form.abv.data,
brewery_id=brewery_id)
# save beer to database
db_session.add(beer)
db_session.commit()
flash('You have successfully added a beer!')
#redirect to view_all_beers
return redirect(url_for('view_all_beers'))
return render_template('add_beer.html',
form=form,
brewery_dropdown_data=brewery_dropdown_data)
def Update(self):
b = Beer(name="Beer1",
organic="Y",
abv=10,
ibu=15,
brewery_id=None,
style_id=None,
images="thisisalink.html")
rev = Review(date="1982-08-09",
rating=5,
comment="Review1 was great!",
beer_name=None,
brewery_name=None)
brw = Brewery(name="Trell",
city="Miami",
state="Florida",
country="USA",
established=1984,
description="Trell is a hip local brewery.",
images="https://www.placeholder.com/image.jpg")
db.session.add(brw)
db.session.add(b)
db.session.add(rev)
db.session.commit()
db.session.query(Beer).update({Beer.brewery_id: 1, Beer.style_id: 1})
db.session.query(Review).update({
Review.beer_name: 1,
Review.brewery_name: 1
})
db.session.commit()
self.assertEqual(b.style_id, 1)
self.assertEqual(b.brewery_id, 1)
self.assertEqual(rev.beer_name, 1)
def add_beer(beer_name):
session = Session()
incoming_data = request.get_json()
beer = session.query(Beer).filter_by(name=beer_name.lower()).first()
if not beer:
beer = Beer(
beer_name,
int(incoming_data["rating"]),
incoming_data["brewerydb_id"],
comment=incoming_data.get("comment")
)
session.add(beer)
else:
beer.rating = int(incoming_data["rating"])
beer.brewerydb_id = incoming_data["brewerydb_id"]
beer.comment = incoming_data.get("comment")
beer.validate()
session.commit()
response = jsonify(ref="/beer/{0}".format(beer.name))
response.status_code = 201
return response
def beer_new(request):
if not request.user.is_superuser:
return redirect('brewhouse-display')
if request.method == 'POST':
form = AddBeerForm(request.POST)
if form.is_valid():
b = Beer()
b.name = form.cleaned_data['name']
b.style = form.cleaned_data['style']
b.recipe_url = form.cleaned_data['recipe_url']
b.save()
# Create some basic events based on the brewed-on date
# tuple is of (event_type, days_since_brew_date)
brew_date = form.cleaned_data['brew_date']
events = (
(7, 0), # brewing
(1, 0), # brewed
(2, 0), # primary fermentation
(3, 7), # secondary fermentation
(4, 21), # kegged
(0, 28), # ready!
)
for etype, num_days in events:
event = Event()
event.beer = b
event.event_type = etype
event.date = brew_date + datetime.timedelta(days=num_days)
event.save()
return redirect('beer-show', b.id)
else:
pass # TODO set an error
else:
form = AddBeerForm()
return render(request, 'brewhouse/new_beer.html', locals())
def update(request, start=None, fetch=None):
"""Update DB with beers from saucer site starting with index (start) and
update no more than (fetch) number of beers"""
if request.method == 'GET':
ids = []
ii = 0
added = 0
skip = 10
saucer = Saucer()
all_beers = saucer.get_all_beers()
num_beers = len(all_beers)
if fetch is not None:
num_beers = int(fetch)
if start is not None:
ii = int(start)
# Don't skip by more than requested
if num_beers < skip:
skip = num_beers
while added < num_beers:
beers = all_beers[ii:ii + skip]
for beer in beers:
ids.append(beer['id'])
details = saucer.get_beer_details(ids)
num_details = len(details)
if not num_details:
break
jj = 0
for det in details:
_type = beers[jj]['type']
_name = beers[jj]['name']
# Maybe we don't find it
try:
curr_beer = Beer.objects.filter(type=_type, name=_name)[0]
except IndexError:
curr_beer = None
# Beer already in db, but maybe it's newly available
if curr_beer:
if not curr_beer.avail:
curr_beer.avail = True
curr_beer.date = datetime.date.today()
curr_beer.save()
added += 1
else:
b = Beer(name=_name, type=_type, avail=True,
style=det['Style:'], descr=det['Description:'])
b.save()
added += 1
jj += 1
ii += skip
ids = []
template_values = {'fetch': saucer.fetch, 'san': saucer.san,
'details': saucer.create_details, 'added': added,
'start': start, 'requested': fetch}
return render_to_response('update.html', template_values)
def index(request): beers = Beer.objects().to_json() return HttpResponse(beers)
def new_beer():
posted_data = request.forms.get('posted_data')
beer = Beer()
beer.name = request.forms.get('name')
beer.cost_crowler = float(request.forms.get('cost_crowler'))
beer.cost_cup = float(request.forms.get('cost_cup'))
beer.cost_pint = float(request.forms.get('cost_pint'))
beer.cost_growler = float(request.forms.get('cost_growler'))
beer.description = request.forms.get('description')
beer.type = request.forms.get('type')
beer.put()
bottle.redirect('beer')
def parse_this(payload):
# Parsing through data. Each item we pull must have every attribute present for us to grab it.
for key,values in payload.items():
if "data" in key:
data = json.dumps(values)
data = json.loads(data)
# Going through the json of the data that we will scrape (each is a beer/brewery/style combo)
for x in data:
b_description = ""
established = ""
country = ""
state = ""
city = ""
website = ""
images = ""
abv = ""
ibu = ""
nameDisplay = ""
organic = ""
pic = ""
shortName = ""
description = ""
ibuMin = ""
ibuMax = ""
abvMin = ""
abvMax = ""
srm = ""
# Checking if brewery exists for a beer and other attributes for a brewery that we have for the model.
if "breweries" in x:
brewery = x['breweries'][0]["name"]
try:
if 'description' in x['breweries'][0]:
b_description = x['breweries'][0]['description']
if len(b_description) > 200:
b_description = ""
except KeyError:
# b_description = "Description Unavailable"
continue
try:
if 'established' in x['breweries'][0]:
established = x['breweries'][0]['established']
# print(established)
except KeyError:
# established = "Unavailable"
continue
if established == "":
continue
try:
if x['breweries'][0]['locations'][0]['country']['displayName'] != None:
country = x['breweries'][0]['locations'][0]['country']['displayName']
except KeyError:
# country = "Country Name Unavailable"
continue
try:
if x['breweries'][0]['locations'][0]['region'] != None:
state = x['breweries'][0]['locations'][0]['region']
except KeyError:
state = "State Name Unavailable"
# continue
try:
if x['breweries'][0]['locations'][0]['region']:
city = x['breweries'][0]['locations'][0]['locality']
except KeyError:
# city = "City Name Unavailable"
continue
try:
if x['breweries'][0]['locations'][0]['website']:
website = x['breweries'][0]['locations'][0]['website']
except KeyError:
# website = "www.empty.com"
continue
try:
if 'images' in x['breweries'][0]:
images = x['breweries'][0]['images']['squareLarge']
except KeyError:
# images = "https://i2.wp.com/www.worldbeersguide.com/wp-content/uploads/2017/01/slide6.jpg"
continue
# print(brewery, b_description, established, country, state, city, website, images)
try:
if x['abv']:
abv = x['abv']
except KeyError:
# abv = "ABV Unavailable"
continue
try:
if x['ibu']:
ibu = x['ibu']
except KeyError:
# ibu = "IBU Unavailable"
continue
try:
if x['nameDisplay']:
nameDisplay = x['nameDisplay']
if nameDisplay in beer_names:
continue
# beer_names.append(u''.join(nameDisplay).encode('utf-8'))
# print(nameDisplay)
except KeyError:
# nameDisplay = "Name Unavailable"
continue
try:
if x['isOrganic']:
organic = x['isOrganic']
except KeyError:
# organic = "Organic-ness Unavailable!"
continue
try:
if x['labels']['large']:
pic = x['labels']['large']
except:
# pic = "www.empty.com"
continue
# Checking if style exists for a beer. We also grab other attributes that we need for our style model.
if 'style' in x:
try:
if x['style']['shortName']:
shortName = x['style']['shortName']
except KeyError:
# shortName = "Style Name Unavailable"
continue
try:
if x['style']['description']:
description = x['style']['description']
except KeyError:
# description = "Description Unavailable"
continue
try:
if x['style']['srmMin'] and x['style']['srmMax']:
srm = (float(x['style']['srmMin']) + float(x['style']['srmMax'])) / 2
except KeyError:
# ibuMin = "IBU Minimum Unavailable"
# assert(False)
continue
try:
if x['style']['ibuMin']:
ibuMin = x['style']['ibuMin']
except KeyError:
# ibuMin = "IBU Minimum Unavailable"
continue
try:
if x['style']['ibuMax']:
ibuMax = x['style']['ibuMax']
except KeyError:
# ibuMax = "IBU Maximum Unavailable"
continue
try:
if x['style']['abvMin']:
abvMin = x['style']['abvMin']
except KeyError:
# abvMin = "ABV Minimum Unavailable"
continue
try:
if x['style']['abvMax']:
abvMax = x['style']['abvMax']
except KeyError:
# abvMax = "ABV Maximum Unavailable"
continue
"""
This is checking if we have not already encountered this style, and if so, make the style
and make the style's pk the beer's fk style to the value recorded. If not, we set
the fk of beer to the value recorded of the style we have already seen.
"""
st_id = -1
if not styles_dic.get(shortName):
st = Style(name=shortName, description=description, ibu_min=float(ibuMin), ibu_max=float(ibuMax), abv_min=float(abvMin), abv_max=float(abvMax), srm=srm)
db.session.add(st)
db.session.commit()
styles_dic[shortName] = st.id
style_obj[shortName] = st
st_id = st.id
else:
st_id = styles_dic[shortName]
st = style_obj[shortName]
"""
Same as the block of code above, only that this deals with breweries.
"""
brw_id = -1
if not brew_dic.get(brewery):
brw = Brewery(name=brewery, city=city, state=state, country=country, established=int(established), description=b_description, images=images, website=website)
db.session.add(brw)
db.session.commit()
brew_dic[brewery] = brw.id
brew_obj[brewery] = brw
brw_id = brw.id
else:
brw_id = brew_dic[brewery]
brw = brew_obj[brewery]
"""
Creating a beer to be put into our database.
"""
b = Beer(name=nameDisplay, organic=organic, abv=float(abv), ibu=float(ibu), brewery_id=brw_id, style_id=st_id, images=pic)
db.session.add(b)
db.session.commit()
brw.styles.append(st)
# This is to append brewery name to the beer name to search in ratebeer.
brew_ind = brewery.lower().find("brew")
if brew_ind == -1:
brew_ind == ""
beer_names.append(u''.join(nameDisplay).encode('utf-8'))
else:
brew_ind = u''.join(brewery[0:(brew_ind)-1]).encode('utf-8')
temp = brew_ind + " " + u''.join(nameDisplay).encode('utf-8')
beer_names.append(temp)
return beer_names
