def add_pet():
"""Shows add pet form; handles form submit."""
form = AddPetForm()
if form.validate_on_submit():
data = {
key: value
for key, value in form.data.items()
if key not in ["csrf_token", "photo_url", "photo_upload"]
}
pet = Pet(**data)
if form.photo_upload.data:
f = form.photo_upload.data
filename = secure_filename(f.filename)
f.save(os.path.join(app.config['UPLOAD_FOLDER'], filename))
pet.photo = url_for('static', filename=filename)
elif form.photo_url.data:
pet.photo = form.photo_url.data
db.session.add(pet)
db.session.commit()
flash(f"Added {pet.name}")
return redirect("/")
else:
return render_template("add_pet.html", form=form)
async def add_pet(self, request):
data = await request.json()
pet = Pet(**data)
pet.save_to_db()
return web.Response(status=201,
body=json.dumps(pet.json()).encode('utf-8'),
content_type='application/json')
def inititalize_redis():
global redis
redis = None
# Get the crdentials from the Bluemix environment
if 'VCAP_SERVICES' in os.environ:
app.logger.info("Using VCAP_SERVICES...")
VCAP_SERVICES = os.environ['VCAP_SERVICES']
services = json.loads(VCAP_SERVICES)
creds = services['rediscloud'][0]['credentials']
app.logger.info("Conecting to Redis on host %s port %s" %
(creds['hostname'], creds['port']))
redis = connect_to_redis(creds['hostname'], creds['port'],
creds['password'])
else:
app.logger.info(
"VCAP_SERVICES not found, checking localhost for Redis")
redis = connect_to_redis('127.0.0.1', 6379, None)
if not redis:
app.logger.info("No Redis on localhost, using: redis")
redis = connect_to_redis('redis', 6379, None)
if not redis:
# if you end up here, redis instance is down.
app.logger.error(
'*** FATAL ERROR: Could not connect to the Redis Service')
# Have the Pet model use Redis
Pet.use_db(redis)
def setup_db():
"Function for setting up database each time we run app.py"
# Create all tables
db.drop_all()
db.create_all()
# If table isn't empty, empty it
Pet.query.delete()
# Add pets
pet1 = Pet(name="Sunshine", species="cat", age="mature", available=False)
pet2 = Pet(
name="Woolfy",
species="dog",
photo_url=
"https://hips.hearstapps.com/hmg-prod.s3.amazonaws.com/images/friendliest-dog-breeds-golden-1578596627.jpg",
age="puppy",
available=True)
# Add new objects to session, so they'll persist
db.session.add(pet1)
db.session.add(pet2)
# Commit--otherwise, this never gets saved!
db.session.commit()
def setUpClass(cls):
db.session.rollback()
Pet.query.delete()
db.session.commit()
Specie.query.delete()
db.session.commit()
cat = Specie(species="cat")
dog = Specie(species="dog")
por = Specie(species="porcupine")
db.session.add_all([cat, dog, por])
db.session.commit()
pet1 = Pet(name="Woofly",
species_id=2,
photo_url="http://127.0.0.1:5000/static/images/woofly.png",
age=1,
notes="woofly-notes")
pet2 = Pet(
name="Taylor",
species_id=1,
photo_url="http://127.0.0.1:5000/static/images/taylor.jpg",
age=8,
notes=
"A truly lovable, friendly cat!! Any adoptee will be lucky to have her.",
available=False)
db.session.add(pet1)
db.session.commit()
db.session.add(pet2)
db.session.commit()
def test_find_by_category(self):
Pet(0, "fido", "dog").save()
Pet(0, "kitty", "cat").save()
pets = Pet.find_by_category("cat")
self.assertNotEqual( len(pets), 0 )
self.assertEqual( pets[0].category, "cat" )
self.assertEqual( pets[0].name, "kitty" )
def add_pet():
"""Add a pet to the list"""
form = AddPetForm()
if form.validate_on_submit():
# name = form.name.data
# species = form.species.data
# photo_url = form.photo_url.data
# age = form.age.data
# notes = form.notes.data
# available = form.available.data
# pet = Pet(name = name, species = species, photo_url = photo_url, age = age, notes = notes, available = available)
data = {
k: v
for k, v in form.data.items() if k != 'csrf_token' and k != 'file'
}
new_pet = Pet(**data)
if form.file.data.filename != '':
filename = images.save(form.file.data)
# if filename != None:
new_pet.photo_url = f'static/{filename}'
else:
new_pet.photo_url = Pet.image_url(new_pet)
db.session.add(new_pet)
db.session.commit()
flash(f'{new_pet.name} is added.')
return redirect('/')
else:
return render_template('add_pet.html', form=form)
def test_find_pet(self):
Pet(0, "fido", "dog").save()
Pet(0, "kitty", "cat").save()
pet = Pet.find(2)
self.assertIsNot( pet, None)
self.assertEqual( pet.id, 2 )
self.assertEqual( pet.name, "kitty" )
def test_get_by_species(self):
pet = Pet(name="TestPet", species="dog", hunger=10)
db.session.add(pet)
db.session.commit()
dogs = Pet.get_by_species('dog')
self.assertEquals(dogs, [pet])
def test_find_by_availability(self):
""" Find a Pet by Availability """
Pet(0, "fido", "dog", False).save()
Pet(0, "kitty", "cat", True).save()
pets = Pet.find_by_availability(True)
self.assertEqual(len(pets), 1)
self.assertEqual(pets[0].name, "kitty")
def post(self):
name = self.request.get('name')
breed = self.request.get('breed')
sex = self.request.get('sex')
birth_date = self.request.get('birth')
city = self.request.get('city')
description = self.request.get('description')
image_url = '/img/' + self.request.POST.multi['picture'].filename
keywords_str = self.request.get('keywords')
keywords = list()
for keyword in keywords_str.split(','):
keywords.append(keyword.strip())
Pet.create(
owner=self.user.key,
breed=breed,
sex=sex,
keywords=keywords,
name=name,
birth_date=birth_date,
city=city,
description=description,
image_url=image_url,
)
self.redirect_to('pets')
def test_find_by_name(self):
""" Find a Pet by Name """
Pet(0, "fido", "dog").save()
Pet(0, "kitty", "cat").save()
pets = Pet.find_by_name("kitty")
self.assertEqual(len(pets), 1)
self.assertEqual(pets[0].category, "cat")
self.assertEqual(pets[0].name, "kitty")
def setUp(self):
""" Runs before each test """
server.init_db()
db.drop_all() # clean up the last tests
db.create_all() # create new tables
Pet(name='fido', category='dog', available=True).save()
Pet(name='kitty', category='cat', available=True).save()
self.app = server.app.test_client()
def test_find_by_name(self):
""" Find a Pet by Name """
Pet(name="fido", category="dog", available=True).save()
Pet(name="kitty", category="cat", available=False).save()
pets = Pet.find_by_name("kitty")
self.assertEqual(pets[0].category, "cat")
self.assertEqual(pets[0].name, "kitty")
self.assertEqual(pets[0].available, False)
def test_deserialize_a_pet(self):
data = {"id":1, "name": "kitty", "category": "cat"}
pet = Pet()
pet.deserialize(data)
self.assertNotEqual( pet, None )
self.assertNotEqual( pet.id, 0 )
self.assertEqual( pet.name, "kitty" )
self.assertEqual( pet.category, "cat" )
def test_deserialize_a_pet(self):
data = {"id": 1, "name": "kitty", "category": "cat", "available": True}
pet = Pet(data['id'])
pet.deserialize(data)
self.assertNotEqual(pet, None)
self.assertEqual(pet.id, 1)
self.assertEqual(pet.name, "kitty")
self.assertEqual(pet.category, "cat")
def add_pet():
""" GET and POST for adding a pet"""
form = PetForm()
if (form.validate_on_submit()):
Pet.add_from_form(form)
return redirect('/')
return render_template('pet_form.html', form=form)
def test_deserialize_a_pet(self):
""" Test deserialization of a Pet """
data = {"id": 1, "name": "kitty", "category": "cat", "available": True}
pet = Pet()
pet.deserialize(data)
self.assertNotEqual(pet, None)
self.assertEqual(pet.id, None)
self.assertEqual(pet.name, "kitty")
self.assertEqual(pet.category, "cat")
self.assertEqual(pet.available, True)
def list_pets():
""" Retrieves a list of pets from the database """
results = []
category = request.args.get('category')
if category:
results = Pet.find_by_category(category)
else:
results = Pet.all()
return jsonify([pet.serialize() for pet in results]), HTTP_200_OK
def test_serialize_a_pet(self):
pet = Pet(0, "fido", "dog")
data = pet.serialize()
self.assertNotEqual( data, None )
self.assertIn( 'id', data )
self.assertEqual( data['id'], 0 )
self.assertIn( 'name', data )
self.assertEqual( data['name'], "fido" )
self.assertIn( 'category', data )
self.assertEqual( data['category'], "dog" )
def list_pets():
pets = []
category = request.args.get('category')
if category:
pets = Pet.find_by_category(category)
else:
pets = Pet.all()
results = [pet.serialize() for pet in pets]
return make_response(jsonify(results), status.HTTP_200_OK)
def list_pets():
""" Retrieves a list of pets from the database """
results = []
category = request.args.get('category')
if category:
results = Pet.find_by_category(category)
else:
results = Pet.all()
return jsonify([pet.serialize() for pet in results]), HTTP_200_OK
def test_for_case_insensitive(self):
""" Test for Case Insensitive Search """
Pet(0, "Fido", "DOG").save()
Pet(0, "Kitty", "CAT").save()
pets = Pet.find_by_name("fido")
self.assertNotEqual(len(pets), 0)
self.assertEqual(pets[0].name, "Fido")
pets = Pet.find_by_category("cat")
self.assertNotEqual(len(pets), 0)
self.assertEqual(pets[0].category, "CAT")
def list_pets():
"""
Retrieve a list of Pets
This endpoint will return all Pets unless a query parameter is specificed
---
tags:
- Pets
description: The Pets endpoint allows you to query Pets
parameters:
- name: category
in: query
description: the category of Pet you are looking for
required: false
type: string
- name: name
in: query
description: the name of Pet you are looking for
required: false
type: string
definitions:
Pet:
type: object
properties:
id:
type: integer
description: unique id assigned internallt by service
name:
type: string
description: the pets's name
category:
type: string
description: the category of pet (e.g., dog, cat, fish, etc.)
responses:
200:
description: An array of Pets
schema:
type: array
items:
schema:
$ref: '#/definitions/Pet'
"""
pets = []
category = request.args.get('category')
name = request.args.get('name')
if category:
pets = Pet.find_by_category(category)
elif name:
pets = Pet.find_by_name(name)
else:
pets = Pet.all()
results = [pet.serialize() for pet in pets]
return make_response(jsonify(results), status.HTTP_200_OK)
def test_add_a_pet(self):
# Create a pet and add it to the database
pets = Pet.all()
self.assertEqual( pets, [])
pet = Pet(0, "fido", "dog")
self.assertTrue( pet != None )
self.assertEqual( pet.id, 0 )
pet.save()
# Asert that it was assigned an id and shows up in the database
self.assertEqual( pet.id, 1 )
pets = Pet.all()
self.assertEqual( len(pets), 1)
def pet_crud():
session = Session()
go_to_gal = session.query(User).filter_by(nickname='Mads').first()
go_to_gal.pets = [Pet(name='Emmy', species='dog', age=2)]
# emmy = session.query(Pet).filter_by(name='Emmy').first()
go_to_gal.pets += [Pet(name='Blub', species='fish')]
# print(go_to_gal.pets)
# session.delete(go_to_gal)
# print(session.query(Pet).filter_by(name='Emmy').count())
session.commit()
def list_pets():
pets = []
category = request.args.get('category')
if category:
pets = Pet.find_by_category(category)
else:
pets = Pet.all()
results = [pet.serialize() for pet in pets]
app.logger.info("results={}".format(results))
j = jsonify(results)
app.logger.info("json={}".format(j))
return make_response(jsonify(results), status.HTTP_200_OK)
def test_serialize_a_pet(self):
""" Test serialization of a Pet """
pet = Pet(name="fido", category="dog", available=False)
data = pet.serialize()
self.assertNotEqual(data, None)
self.assertIn('id', data)
self.assertEqual(data['id'], None)
self.assertIn('name', data)
self.assertEqual(data['name'], "fido")
self.assertIn('category', data)
self.assertEqual(data['category'], "dog")
self.assertIn('available', data)
self.assertEqual(data['available'], False)
def test_delete_a_pet(self):
pet = Pet(0, "fido", "dog")
pet.save()
self.assertEqual( len(Pet.all()), 1)
# delete the pet and make sure it isn't in the database
pet.delete()
self.assertEqual( len(Pet.all()), 0)
def list_pets():
""" Returns all of the Pets """
pets = []
category = request.args.get('category')
name = request.args.get('name')
if category:
pets = Pet.find_by_category(category)
elif name:
pets = Pet.find_by_name(name)
else:
pets = Pet.all()
results = [pet.serialize() for pet in pets]
return make_response(jsonify(results), status.HTTP_200_OK)
def test_delete_a_pet(self):
""" Delete a Pet """
pet = Pet(name="fido", category="dog", available=True)
pet.save()
self.assertEqual(len(Pet.all()), 1)
# delete the pet and make sure it isn't in the database
pet.delete()
self.assertEqual(len(Pet.all()), 0)
def new_pet():
"""
form to add new pet & validation to add to database
"""
form = PetForm()
if form.validate_on_submit():
# ===original method below====
# name = form.name.data
# species = form.species.data
# photo_url = form.photo_url.data
# age = form.age.data
# notes = form.notes.data
# available = form.available.data
# pet = Pet(name=name, species=species, photo_url=photo_url, age = age, notes = notes, available = available)
# method to loop over dictionary so that it updates if new fields get added
data = {k: v for k, v in form.data.items() if k != "csrf_token"}
new_pet = Pet(**data)
# the input data looks like === new_pet = Pet(name=form.name.data, age=form.age.data, ...)
db.session.add(new_pet)
db.session.commit()
flash(f'{new_pet.name} added', 'alert alert-success')
return redirect('/')
else:
return render_template('new_pet_form.html', form=form)
def get_pets(id):
""" Retrieves a Pet with a specific id """
pet = Pet.find(id)
if pet:
message = pet.serialize()
return_code = HTTP_200_OK
else:
message = {'error' : 'Pet with id: %s was not found' % str(id)}
return_code = HTTP_404_NOT_FOUND
return jsonify(message), return_code
def update_pets(id):
""" Updates a Pet in the database fom the posted database """
pet = Pet.find(id)
if pet:
payload = request.get_json()
pet.deserialize(payload)
pet.save()
message = pet.serialize()
return_code = HTTP_200_OK
else:
message = {'error' : 'Pet with id: %s was not found' % str(id)}
return_code = HTTP_404_NOT_FOUND
return jsonify(message), return_code
def test_update_a_pet(self):
pet = Pet(0, "fido", "dog")
pet.save()
self.assertEqual( pet.id, 1 )
# Change it an save it
pet.category = "k9"
pet.save()
self.assertEqual( pet.id, 1 )
# Fetch it back and make sure the id hasn't changed
# but the data did change
pets = Pet.all()
self.assertEqual( len(pets), 1)
self.assertEqual( pets[0].category, "k9")
def create_pets():
""" Creates a Pet in the datbase from the posted database """
payload = request.get_json()
pet = Pet()
pet.deserialize(payload)
pet.save()
message = pet.serialize()
response = make_response(jsonify(message), HTTP_201_CREATED)
response.headers['Location'] = url_for('get_pets', id=pet.id, _external=True)
return response
def test_find_with_no_pets(self):
pet = Pet.find(1)
self.assertIs( pet, None)
def delete_pets(id):
""" Removes a Pet from the database that matches the id """
pet = Pet.find(id)
if pet:
pet.delete()
return make_response('', HTTP_204_NO_CONTENT)
def test_pet_not_found(self):
Pet(0, "fido", "dog").save()
pet = Pet.find(2)
self.assertIs( pet, None)
def setUp(self):
Pet.remove_all()
