def setUp(self):
test_vet_peter = Vet("Peter", False)
test_vet_mark = Vet("Mark", False)
test_vet_paul = Vet("Paul", False)
test_owner_david = Owner("David", "Edinburgh", False)
test_owner_carl = Owner("Carl", "liverpool", False)
test_owner_jamie = Owner("Jamie", "Glasgow", False)
test_owner_sarah = Owner("Sarah", "London", False)
self.test_animal_pepper = Animal("Pepper", "10/11/2015", "Horse",
test_owner_david, test_vet_paul,
False)
self.test_animal_luna = Animal("Mika", "01/03/2012", "Cat",
test_owner_david, test_vet_mark, False)
self.test_animal_buddy = Animal("Buddy", "19/01/2014", "Rabbit",
test_owner_carl, test_vet_peter, False)
self.test_animal_snowy = Animal("Snowy", "17/02/2015", "Dog",
test_owner_carl, test_vet_peter, False)
self.test_animal_lola = Animal("Lola", "04/08/2018", "Cow",
test_owner_jamie, test_vet_peter, False)
self.test_animal_apollo = Animal("Apollo", "22/03/2016", "Dog",
test_owner_jamie, test_vet_paul,
False)
self.test_animal_buster = Animal("Buster", "29/04/2019", "Dog",
test_owner_sarah, test_vet_paul,
False)
self.test_animal_izzy = Animal("Izzy", "30/05/2020", "Cat",
test_owner_sarah, test_vet_mark, False)
def detail(action, id):
if request.method == 'GET':
animals = animal_repository.select_all_by_owner_id(id)
owner = owner_repository.select_id(id)
len_animals = len(animal_repository.select_all_by_owner_id(id))
if action == "show":
return render_template("owners/show.html.j2",
owner=owner,
len_animals=len_animals)
elif action == "edit":
return render_template("owners/edit.html.j2", owner=owner)
elif action == "animals":
return render_template("owners/detail.html.j2",
owner=owner,
len_animals=len_animals,
animals=animals)
elif action == "orphaned":
animals = animal_repository.select_all_by_owner_id(1)
active_owners = owner_repository.select_all_active()
return render_template("owners/orphaned.html.j2",
active_owners=active_owners,
owner=owner,
len_animals=len_animals,
animals=animals)
else:
message = "Malformed URL"
return redirect(url_for("owners.index", message=message))
if request.method == 'POST':
if action == "delete":
owner_repository.delete_id(request.form['id'])
message = f"Owner: {owner.name} (id:{owner.id}) deleted"
return redirect(url_for("owners.index", message=message))
elif action == "edit":
name = request.form['name']
address = request.form['address']
try:
deactivated = request.form['deactivated']
except:
deactivated = False
id = request.form['id']
owner = Owner(name, address, deactivated, id)
owner_repository.update(owner)
message = f"Owner: {owner.name} (id:{owner.id}) updated"
return redirect(url_for("owners.index", message=message))
elif action == "deactivate":
owner = owner_repository.select_id(id)
animals = animal_repository.select_all_by_owner_id(id)
for animal in animals:
animal.owner = owner_repository.select_id(1)
animal_repository.update(animal)
owner.deactivated = True
owner_repository.update(owner)
message = f"All animals moved to No Owner, Owner {owner.name} deactivated, please reassign"
return redirect(url_for("owners.index", message=message))
else:
message = "Malformed URL"
return redirect(url_for("owners.index", message=message))
def create_new_owner():
name = request.form['name']
contact = request.form['contact']
postal_address = request.form['address']
new_Owner = Owner(name, contact, postal_address, 0)
owner_repository.save(new_Owner)
return redirect("/owners")
def edit_owner(id):
name = request.form["name"]
phone_number = request.form["phone"]
address = request.form["address"]
owner = Owner(name, phone_number, address, id)
owner_repository.update_owner(owner)
return redirect('/owners/' + id + '/more')
def add_new_owner():
name = request.form["name"].capitalize()
phone_number = request.form["phone"]
address = request.form["address"].capitalize()
owner = Owner(name, phone_number, address)
owner_repository.save_new_owner(owner)
return redirect('/owners')
def get_pubsub_data(self, devicedata_entry):
# type: (DeviceData) -> dict
data = devicedata_entry.to_json()
# Previous locations
device = devicedata_entry.device_key.get()
previous_5 = devicedata_entry.get_last(device, n=6)
try:
previous_5.remove(devicedata_entry)
except ValueError:
pass
data['previous'] = [prev.to_json() for prev in previous_5]
# Phone data
system = device.system_key.get()
owned = Owner.from_system(system)
secondary_nums = Secondary.get_all_contact_numbers(system)
try:
phone_numbers = [owned.get_contact_number()] + secondary_nums
except AttributeError:
raise LookupError("No system owner.")
data['phones'] = phone_numbers
return data
def setUp(self):
self.vet_1 = Vet("John", "Smith")
self.owner_1 = Owner("Cpt.", "Jack", "Harkness", "07411000000", True)
self.animal_1 = Animal("Tigger", datetime.date(2019, 5, 1), "Tiger",
self.owner_1)
self.animal_2 = Animal("Roger", datetime.date(2018, 7, 2), "Rabbit",
self.owner_1, self.vet_1)
def save():
# Get data from request
first_name = request.form['owner_first_name']
last_name = request.form['owner_last_name']
email = request.form['owner_email']
contact_no = request.form['owner_contact_number']
address = request.form['owner_address']
post_code = request.form['owner_post_code']
city = request.form['owner_city']
if len(first_name) > 48:
return_error('ao-1') # Return error code 1: Firstname too long
elif len(last_name) > 48:
return_error('ao-2') # Return error code 2: Lastname too long
elif len(email) > 100:
return_error('ao-3') # Return error code 3: Email address too long
elif len(contact_no) > 11:
return_error('ao-4') # Return error code 4: Contact number too long
elif len(address) > 100:
return_error('ao-5') # Return error code 5: Address too long
elif len(post_code) > 8:
return_error('ao-6') # Return error code 6: Post code too long
elif len(city) > 100:
return_error('ao-7') # Return error code 7: City too long
# Create new owner object to be saved
owner = Owner(first_name, last_name, email, contact_no, address, post_code, city, True)
OR.save(owner)
return redirect('/owners')
def get(self, oauth_id=None):
"""
Gets current user information.
:param oauth_id:
:return: models/user/User plus owned_systems, secondary_systems
"""
if oauth_id is None:
oauth_id = current_user.oauth_id
if current_user.oauth_id != oauth_id:
# TODO: Check for admin status here.
abort(403)
data = current_user.to_json()
owned = OwnerModel.from_user(current_user)
try:
owned_data = owned.system_key.get().to_json()
except AttributeError:
data['owned_systems'] = []
else:
data['owned_systems'] = [owned_data, ]
secondary = Secondary.from_user(current_user)
secondary_data = [s.system_key.get().to_json() for s in secondary]
data['secondary_systems'] = secondary_data
return jsonify(data)
def syncClient():
userData = request.get_json()
user = Owner(userData['publicKey'], userData['privateKey'],
userData['type'], userData['name'], userData['password'],
userData['username'])
users[userData['username']] = user
return "Done", 200
def post(self):
data = request.get_json()
system_id = data.get('system_id')
user_email = data.get('user_email')
if None in (system_id, user_email):
abort(400)
system = System.from_system_id(system_id)
user = User.from_email(user_email)
if None in (system, user):
abort(400)
if current_user == user:
abort(400)
if not Owner.is_owner_of(current_user, system):
abort(401)
sec_obj = SecondaryModel.create(user, system)
sec_obj.put()
secondaries = SecondaryModel.from_system(system)
if sec_obj not in secondaries:
secondaries.append(sec_obj)
ret = self.get_response_map_from_secondaries(secondaries)
return jsonify(ret)
def associate_device(self, device, system):
if device is None:
abort(400)
try:
curr_system = device.system_key.get()
except AttributeError:
curr_system = None
if system is None:
abort(400, 'Invalid system.')
if curr_system is not None:
abort(401, 'Device already associated.')
if not Owner.is_owner_of(current_user, system):
abort(401)
device.system_key = system.key
device.put()
devices = DeviceModel.from_system_key(system.key)
if device not in devices:
devices.append(device)
return system, devices
def select(id):
owner = None
sql = "SELECT * FROM owners WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
if result is not None:
owner = Owner(result['first_name'], result['last_name'], result['id'])
return owner
def get(self, system_id):
system = System.from_system_id(system_id)
if system is None or not Owner.is_owner_of(current_user, system):
abort(400)
secondaries = SecondaryModel.from_system(system)
ret = self.get_response_map_from_secondaries(secondaries)
return jsonify(ret)
def select(id):
sql = "SELECT * FROM owners WHERE id = %s"
values = [id]
results = run_sql(sql, values)[0]
if results is not None:
owner = Owner(results['name'], results['id'])
return owner
def select_all():
owners = []
sql = "SELECT * FROM owners"
results = run_sql(sql)
for row in results:
owner = Owner(row['name'])
owners.append(owner)
return owners
def update(id):
name = request.form['name']
contact = request.form['contact']
address = request.form['address']
balance = request.form['balance']
owner = Owner(name, contact, address, balance, id)
owner_repository.update(owner)
return redirect("/owners")
def setUp(self):
owner = Owner('Jack',
'White',
'*****@*****.**',
'487239847',
True,
id=3)
self.testimonial = Testimonial('this is a testimonial', owner, 2)
def select(id):
sql = 'SELECT * FROM owners WHERE id = %s'
values = [id]
result = run_sql(sql, values)[0]
owner = Owner(result['first_name'], result['last_name'],
result['phone_num_1'], result['phone_num_2'],
result['address'], result['id'])
return owner
def select_all_owners():
results = run_sql("SELECT * FROM owners WHERE archived=%s", ["FALSE"])
owners = []
for result in results:
owner = Owner(result["name"], result["phone_number"],
result["address"], result["id"])
owners.append(owner)
return owners
def select_owner(id):
sql = "SELECT * FROM owners WHERE id=%s"
value = [id]
result = run_sql(sql, value)[0]
if result is not None:
owner = Owner(result["name"], result["phone_number"],
result["address"], result["id"])
return owner
def setUp(self):
owner = Owner('Jack',
'White',
'*****@*****.**',
'487239847',
True,
id=5)
self.feedback = Feedback(1, 2, 3, 4, 'sugg', 'oth', owner, 6)
def update_owner(id):
first_name = request.form['first_name']
last_name = request.form['last_name']
phone_num_1 = request.form['phone_num_1']
phone_num_2 = request.form['phone_num_2']
address = request.form['address']
owner = Owner(first_name, last_name, phone_num_1, phone_num_2, address, id)
owner_repository.update(owner)
return redirect('/owners')
def select(id):
owner = None
sql = "SELECT * FROM owners WHERE id = %s"
values = [id]
results = run_sql(sql, values)[0]
if results is not None:
owner = Owner(results['name'], results['contact'], results['address'],
results['balance'], results['id'])
return owner
def select(id):
owner = None
sql = "SELECT * FROM owners WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
if result is not None:
owner = Owner(result["name"], result["id"])
return owner
def select_all():
owners = []
sql = "SELECT * FROM owners"
results = run_sql(sql)
for row in results:
owner = Owner(row['name'], row['contact'], row['address'],
row['balance'], row['id'])
owners.append(owner)
return owners
def test_owner_create(random_user):
owner = Owner.create(random_user, 60)
owner.put()
assert owner.user_key == random_user.key
assert owner.system_key is not None
system = owner.system_key.get()
assert system.grace_period == 60
def __init__(self):
self.name = ""
self.owner = Owner()
self.description = ""
self.clientele = ""
self.costPerNight = ""
self.menu = Menu()
self.lifestyle = Lifestyle.SQUALID
self.cost = ""
def add_owner_POST():
first_name = request.form.get('first_name')
last_name = request.form.get('last_name')
email = request.form.get('email')
phone = request.form.get('phone')
register = request.form.get('register')
owner = Owner(first_name, last_name, email, phone, register)
OwnerRep().save(owner)
return redirect('/owners/all')
def post(self):
data = request.get_json()
if data is None:
abort(401)
grace = data.get('grace_period')
oauth = data.get('oauth_id')
user = UserModel.from_oauth_id(oauth_id=oauth)
entry = OwnerModel.create(user, grace)
entry.put()
return jsonify({})
