def test_create_new_person_with_drink(self, save_new_user_in_database):
# Select the first option to create
test_name = ' TestName '
drink_option = '1'
# INPUTS
# Julio: Repeated name to verify that it is not allowed to repeat name in the list of persons
# TestName: Unique name
# 'Y': option to select that I want to add the favorite drink of the new period.
# '99': Incorrect number for the moment of choosing a drink from the list.
# drinkOption: Correct number for the moment of choosing a drink from the list
input_values = ['Julio', test_name, 'Y', '99', drink_option]
mock_inputs(input_values)
people = [Person('Julio'), Person('Dani')]
drinks = [Drink('Water'), Drink('Coffee')]
save_new_user_in_database.return_value = Person(
test_name.strip(), drinks[int(drink_option) - 1], 12)
people = functions.create_new_person(people, drinks)
self.assertTrue(len(people) == 3)
self.assertTrue(people[-1].name == test_name.strip())
self.assertTrue(
people[-1].favourite_drink.name == drinks[int(drink_option) -
1].name)
def read_rounds(filepath):
rounds = []
try:
with open(filepath, "r") as rounds_file:
for line in rounds_file.readlines():
orders = line.strip().split(";")
date = datetime.strptime(orders[0], texts.DATE_FORMAT)
brewer = orders[1]
round_orders = []
for order in orders[2:]:
_order = order.split(",")
round_orders.append(
Order(Person(_order[0]), Drink(_order[1])))
rounds.append(Round(round_orders, date, Person(brewer)))
except FileNotFoundError as filenotfound:
print(
f"Could no open the file {filepath}. /nError: {str(filenotfound)}")
error_opening_file()
except Exception as e:
print(
f"Error opening the file {filepath}. /nError: {str(e)}")
error_opening_file()
return rounds
def test_not_allow_the_creation_of_a_round_if_an_open_one_already_exists(
self):
people = [Person('Julio'), Person('Dani')]
rounds = [Round()]
new_rounds = functions.create_round_and_set_brewer(people, rounds)
self.assertEqual(rounds, new_rounds)
def get_rounds_from_database(is_open_filter=None):
rounds = []
db = Database(Config)
query = """
SELECT r.is_open, r.brewer as brewer_id, r.open_date, r.round_id,
p.name as brewer_name, p2.name as person_name, d.name as drink_name,
d.drink_id, p2.person_id, o.order_id
FROM BrewOrder as o
RIGHT JOIN BrewRound as r
ON o.round_id = r.round_id
INNER JOIN Person as p
ON p.person_id = r.brewer
LEFT JOIN Drink as d
ON d.drink_id = o.drink_id
LEFT JOIN Person as p2
ON p2.person_id = o.person_id
"""
if is_open_filter != None and isinstance(is_open_filter, bool):
query += f" WHERE r.is_open={int(is_open_filter)}"
query += " ORDER BY r.round_id"
db_rounds = db.run_query(query)
rounds = []
if len(db_rounds) != 0:
curret_round = db_rounds[0]
round_orders = []
for idx, order in enumerate(db_rounds):
if curret_round['round_id'] != order['round_id'] or idx == len(
db_rounds):
rounds.append(
Round(
round_orders, curret_round['open_date'],
Person(curret_round['brewer_name'], None,
curret_round['brewer_id']),
curret_round['is_open'], curret_round['round_id']))
curret_round = order
round_orders = []
if order['person_name']:
round_orders.append(
Order(
Person(order['person_name'],
person_id=order['person_id']),
Drink(order['drink_name'], order['drink_id']),
order['order_id']))
rounds.append(
Round(
round_orders, curret_round['open_date'],
Person(curret_round['brewer_name'], None,
curret_round['brewer_id']), curret_round['is_open'],
curret_round['round_id']))
return rounds
def test_ask_unique_name(self):
test_name = 'TestName'
repeat_name = 'Repeat'
people = [Person(repeat_name), Person('Dani')]
inputs = [repeat_name, test_name]
mock_inputs(inputs)
new_name = functions.ask_unique_name(people, 'test')
self.assertEqual(new_name, test_name)
def test_close_open_round(self, close_round_in_database):
people = [Person('Julio'), Person('Dani')]
rounds = [Round(brewer=people[0])]
input_values = ['Y']
mock_inputs(input_values)
close_round_in_database.return_value = Round(is_open=False,
brewer=people[0])
new_rounds = functions.close_open_round(rounds)
self.assertTrue(new_rounds[-1].brewer.name == people[0].name)
self.assertTrue(new_rounds[-1].is_open == False)
def create_new_person(people, drinks):
"""
Requests by console the necessary information to create a new person,
which are, name and favourite drink. Checks if this user already exists.
And finaly save this new person in cache and write in the people file.
+ Parameters:
- people: list of people
- drinks: list of drinks
"""
drink = None
name = ask_unique_name(people, texts.ENTER_NAME)
if len(name) != 0:
add_drink = ask_boolean(texts.QUESTION_ADD_DRINK)
if add_drink:
drink_id = ask_drink_in_list(drinks, texts.ENTER_DRINK_ID)
if drink_id != 0:
drink = drinks[drink_id - 1]
p = Person(name, drink)
try:
saved_person = people_controller.save_new_user_in_database(p)
people.append(saved_person)
except DatabaseError:
print(texts.DATABASE_ERROR + texts.PERSON_NOT_ADDED)
return people
def test_set_favourite_drink(self):
# INPUTS
# '1': person id in the people list
# '2': drink id in the drinks list
input_values = ['1', '2']
mock_inputs(input_values)
people = [Person('Julio'), Person('Dani')]
drinks = [Drink('Water'), Drink('Coffee')]
people = functions.set_favourite_drink(people, drinks)
self.assertTrue(people[0].name == 'Julio')
self.assertTrue(people[0].favourite_drink.name == drinks[1].name)
self.assertTrue(people[1].favourite_drink == None)
def test_create_new_round_and_set_maker(self,
create_new_open_round_in_database):
maker_selected_id = '1'
people = [Person('Julio'), Person('Dani')]
rounds = [Round(is_open=False)]
input_values = [maker_selected_id]
mock_inputs(input_values)
create_new_open_round_in_database.return_value = Round(
brewer=people[int(maker_selected_id) - 1])
new_rounds = functions.create_round_and_set_brewer(people, rounds)
self.assertTrue(len(new_rounds) == 2)
self.assertTrue(new_rounds[-1].is_open)
self.assertEqual(new_rounds[-1].brewer,
people[int(maker_selected_id) - 1])
def save_new_user_in_database(new_user: Person):
db = Database(Config)
query = f"""INSERT INTO Person(name) VALUES ('{new_user.name}')"""
if new_user.favourite_drink != None:
query = f"""INSERT INTO Person(name,favourite_drink_id)
VALUES ('{new_user.name}', {new_user.favourite_drink.drink_id})"""
new_user.person_id = db.run_query(query)
return new_user
def test_create_new_person_without_drink(self):
# Select the first option to create
testName = ' TestName '
# INPUTS
# Julio: Repeated name to verify that it is not allowed to repeat name in the list of persons
# TestName: Unique name
# 'N': option to select that I don't want to add the favorite drink of the new period.
# '99': Incorrect number for the moment of choosing a drink from the list.
# drinkOption: Correct number for the moment of choosing a drink from the list
input_values = ['Julio', 'TestName', 'N']
mock_inputs(input_values)
people = [Person('Julio'), Person('Dani')]
drinks = [Drink('Water'), Drink('Coffee')]
functions.create_new_person(people, drinks)
self.assertTrue(len(people) == 3)
self.assertTrue(people[len(people) - 1].name == testName.strip())
self.assertTrue(people[len(people) - 1].favourite_drink == None)
def get_round_by_id(round_id):
db = Database(Config)
query = f"""
SELECT r.is_open, r.brewer as brewer_id, r.open_date, r.round_id,
p.name as brewer_name, p2.name as person_name, d.name as drink_name,
d.drink_id, p2.person_id, o.order_id
FROM BrewOrder as o
RIGHT JOIN BrewRound as r
ON o.round_id = r.round_id
INNER JOIN Person as p
ON p.person_id = r.brewer
LEFT JOIN Drink as d
ON d.drink_id = o.drink_id
LEFT JOIN Person as p2
ON p2.person_id = o.person_id
WHERE r.round_id = {round_id}
"""
db_orders = db.run_query(query)
if len(db_orders) == 0:
return None
round_orders = []
for order in db_orders:
if order['person_name']:
round_orders.append(
Order(
Person(order['person_name'], person_id=order['person_id']),
Drink(order['drink_name'], order['drink_id']),
order['order_id']))
rount_to_return = Round(
round_orders, db_orders[0]['open_date'],
Person(db_orders[0]['brewer_name'], None, db_orders[0]['brewer_id']),
db_orders[0]['is_open'], db_orders[0]['round_id'])
return rount_to_return
def test_add_order_to_round(self, add_order_to_round_in_database):
selected_person_id = '1'
selected_drink_id = '1'
people = [Person('Julio'), Person('Dani')]
drinks = [Drink('Water'), Drink('Coffee')]
rounds = [Round(brewer=people[0])]
new_order = Order(people[int(selected_person_id) - 1],
drinks[int(selected_drink_id) - 1])
orders = [new_order]
expected_rounds = [Round(orders)]
input_values = [selected_person_id, selected_drink_id]
mock_inputs(input_values)
add_order_to_round_in_database.return_value = new_order
new_rounds = functions.add_order_to_round(people, drinks, rounds)
self.assertTrue(new_rounds[-1].orders[-1].drink.name ==
expected_rounds[-1].orders[-1].drink.name)
self.assertTrue(new_rounds[-1].orders[-1].person.name ==
expected_rounds[-1].orders[-1].person.name)
def post_round(handler, data):
try:
brewer_person = Person(person_id=data['brewer_id'])
new_round = Round(brewer=brewer_person)
create_new_open_round_in_database(new_round)
handler.send_response(201)
except KeyError as e:
print("JSON KEY ERRORS: " + str(e))
handler.send_response(400)
except DatabaseError:
handler.send_response(500)
print(texts.DATABASE_ERROR + texts.ROUND_NOT_ADDED)
finally:
handler.end_headers()
def test_set_favourite_drink(self, update_user_in_database):
person_id = '1'
drink_id = '2'
# INPUTS
# '1': person id in the people list
# '2': drink id in the drinks list
input_values = [person_id, drink_id]
mock_inputs(input_values)
people = [Person('Julio'), Person('Dani')]
drinks = [Drink('Water'), Drink('Coffee')]
update_user_in_database.return_value = Person(
people[int(person_id) - 1].name, drinks[int(drink_id) - 1].name,
12)
people = functions.set_favourite_drink(people, drinks)
self.assertTrue(people[0].name == 'Julio')
self.assertTrue(people[0].favourite_drink.name == drinks[1].name)
self.assertTrue(people[1].favourite_drink == None)
def post_people(handler, data):
try:
new_person = Person(data['name'], Drink('',
data['favourite_drink_id']))
save_new_user_in_database(new_person)
handler.send_response(201)
except KeyError as e:
print("JSON KEY ERRORS: " + str(e))
handler.send_response(400)
except DatabaseError:
handler.send_response(500)
print(texts.DATABASE_ERROR + texts.ROUND_NOT_ADDED)
finally:
handler.end_headers()
def get_person_by_id_from_database(person_id):
db = Database(Config)
db_users = db.run_query(
f"""SELECT p.person_id, p.name as person_name, p.favourite_drink_id, d.name as drink_name
FROM Person AS p INNER JOIN Drink as d ON p.favourite_drink_id = d.drink_id WHERE p.person_id = {person_id} """
)
if len(db_users) != 0:
user = db_users[0]
return Person(user['person_name'],
Drink(user['drink_name'], user['favourite_drink_id']),
user['person_id'])
else:
return None
def get_people_by_favourite_drink_from_database(drink_id):
db = Database(Config)
db_people = db.run_query(
f"""SELECT p.person_id, p.name as person_name, p.favourite_drink_id, d.name as drink_name
FROM Person AS p INNER JOIN Drink as d ON p.favourite_drink_id = d.drink_id WHERE p.favourite_drink_id = {drink_id} """
)
people = []
for person in db_people:
people.append(
Person(person['person_name'],
Drink(person['drink_name'], person['favourite_drink_id']),
person['person_id']))
return people
def web_people():
if request.method == 'GET':
people = get_people_from_database()
drinks = get_drinks_from_database()
return render_template('people.html',
title='People',
people=people,
drinks=drinks)
if request.method == 'POST':
drink_id = request.form.get('drink_id')
drink = None
if drink_id != 'None':
drink = get_drink_by_id_from_database(drink_id)
person_name = request.form.get('person_name').strip()
people = get_people_from_database()
drinks = get_drinks_from_database()
if len(person_name) == 0:
return render_template(
'people.html',
title='People',
people=people,
drinks=drinks,
error_message='The name of the person cannot be empty')
if len(search_person_by_name(person_name)) > 0:
return render_template(
'people.html',
title='People',
people=people,
drinks=drinks,
error_message='There is already a person with that name')
new_person = Person(person_name, drink)
saved_person = save_new_user_in_database(new_person)
people.append(saved_person)
return render_template('people.html',
title='People',
people=people,
drinks=drinks)
else:
return "Unsupported HTTP Request Type"
def post_add_order_to_round(handler, data):
try:
open_round = Round(round_id=data['round_id'])
new_order = Order(Person(person_id=data['person_id']),
Drink(drink_id=data['drink_id']))
add_order_to_round_in_database(open_round, new_order)
handler.send_response(201)
except KeyError as e:
print("JSON KEY ERRORS: " + str(e))
handler.send_response(400)
except DatabaseError:
handler.send_response(500)
print(texts.DATABASE_ERROR + texts.ROUND_NOT_ADDED)
finally:
handler.end_headers()
def get_people_from_database():
users = []
db = Database(Config)
db_users = db.run_query(
"""SELECT p.person_id, p.name as person_name, p.favourite_drink_id, d.name as drink_name
FROM Person AS p LEFT JOIN Drink as d ON p.favourite_drink_id = d.drink_id"""
)
for user in db_users:
users.append(
Person(user['person_name'],
Drink(user['drink_name'], user['favourite_drink_id']),
user['person_id']))
return users
def search_person_by_name(person_name):
db = Database(Config)
people = []
db_users = db.run_query(
f"""SELECT p.person_id, p.name as person_name, p.favourite_drink_id, d.name as drink_name
FROM Person AS p INNER JOIN Drink as d ON p.favourite_drink_id = d.drink_id WHERE upper(p.name) = '{person_name.strip().upper()}' """
)
if len(db_users) != 0:
for user in db_users:
people.append(
Person(user['person_name'],
Drink(user['drink_name'], user['favourite_drink_id']),
user['person_id']))
return people
def read_people_from_file(filepath):
people = []
try:
with open(filepath, "r") as people_file:
for person in people_file.readlines():
line = person.split(":")
drink = None
if line[1].strip() != 'None':
drink = Drink(line[1].strip())
people.append(Person(line[0], drink))
except FileNotFoundError as filenotfound:
print(
f"Could no open the file {filepath}. /nError: {str(filenotfound)}")
error_opening_file()
except Exception as e:
print(f"Error opening the file {filepath}. /nError: {str(e)}")
error_opening_file()
return people
def create_new_person(people, drinks):
"""
Requests by console the necessary information to create a new person,
which are, name and favourite drink. Checks if this user already exists.
And finaly save this new person in cache and write in the people file.
+ Parameters:
- people: list of people
- drinks: list of drinks
"""
drink = None
name = ask_unique_name(people, texts.ENTER_NAME)
if len(name) != 0:
add_drink = ask_boolean(texts.QUESTION_ADD_DRINK)
if add_drink:
drink_id = ask_drink_in_list(drinks, texts.ENTER_DRINK_ID)
if drink_id != 0:
drink = drinks[drink_id - 1]
p = Person(name, drink)
people.append(p)
return people
def api_get_people():
if request.method == 'GET':
people = get_people_from_database()
return {'People': [person.to_json() for person in people]}
if request.method == 'POST':
data = request.get_json() or {}
if 'name' not in data or 'favourite_drink_id' not in data:
return Response(
status=400,
response='must include name and favourite_drink_id fields')
drink = get_drink_by_id_from_database(data['favourite_drink_id'])
if drink == None:
return Response(status=400,
response='there is no drink with that id')
new_person = Person(data['name'], drink)
save_person = save_new_user_in_database(new_person)
response = jsonify(save_person.to_json())
response.status_code = 201
return response
else:
return "Unsupported HTTP Request Type"