def generate_random_reservation(user_id=None,
restaurant_id=None,
people_number=None,
start_time_mode=None):
from gooutsafe.models.reservation import Reservation
faker = Faker()
if user_id is None:
user_id = faker.random_int(min=1, max=50000)
table_id = faker.random_int(min=1, max=50000)
if restaurant_id is None:
restaurant_id = faker.random_int(min=1, max=50000)
if people_number is None:
people_number = faker.random_int(min=0, max=10)
if start_time_mode == 'valid_past_contagion_time':
start_time = faker.date_time_between_dates(
datetime.utcnow() - timedelta(days=14), datetime.utcnow())
elif start_time_mode == 'valid_future_contagion_time':
start_time = faker.date_time_between('now', '+14d')
else:
start_time = TestReservation.faker.date_time_between('now', '+6w')
reservation = Reservation(user_id=user_id,
table_id=table_id,
restaurant_id=restaurant_id,
people_number=people_number,
start_time=start_time)
return reservation, (user_id, table_id, restaurant_id, start_time)
def create_reservation(restaurant_id):
"""This method allows the customer to create a new reservation, on a specific restaurant,
depending on its opening hours and the available tables
Args:
restaurant_id (int): univocal identifier of the restaurant
"""
if current_user.type == 'customer':
form = ReservationForm()
restaurant = RestaurantManager.retrieve_by_id(restaurant_id)
if request.method == 'POST':
if form.validate_on_submit():
start_date = form.data['start_date']
start_time = form.data['start_time']
people_number = form.data['people_number']
start_time_merged = datetime.combine(start_date, start_time)
table = validate_reservation(restaurant, start_time_merged,
people_number)
if table != False:
reservation = Reservation(current_user, table, restaurant,
people_number, start_time_merged)
ReservationManager.create_reservation(reservation)
return redirect(
url_for('reservation.customer_my_reservation'))
else:
flash(
"There aren't free tables for that hour or the restaurant is close"
)
else:
flash("Take a look to the inserted data")
return render_template('create_reservation.html',
restaurant=restaurant,
form=form)
return redirect(url_for('home.index'))
def create_reservation():
"""This method is used to create a new reservation
Linked to route /reservation/ [POST]
Returns:
Invalid request if the creation of the reservation is not successful
A json specifying the info needed to render the reservation page otherwise
"""
try:
json_data = request.get_json()
user_id = json_data['user_id']
restaurant_id = json_data['restaurant_id']
start_time = json_data['start_time']
people_number = json_data['people_number']
tables = json_data['tables']
times = json_data['times']
table_id, start_time = validate_reservation(tables, times, start_time,
people_number)
if table_id is False:
raise ValueError
reservation = Reservation(user_id, table_id, restaurant_id,
people_number, start_time)
ReservationManager.create_reservation(reservation)
except Exception as e:
return jsonify({
'status':
'Bad request',
'message':
'The data provided were not correct.\n' + str(e)
}), 400
return jsonify({
'status': 'Success',
'message': 'Reservation succesfully added'
}), 200
def generate_random_reservation(user=None,
restaurant=None,
start_time_mode=None):
from gooutsafe.models.reservation import Reservation
test_reservation = TestReservation()
test_reservation.setUpClass()
if user is None:
user = test_reservation.test_user.generate_random_user()
table, _ = test_reservation.test_table.generate_random_table()
if restaurant is None:
restaurant, _ = test_reservation.test_restaurant.generate_random_restaurant(
)
people_number = test_reservation.faker.random_int(
min=0, max=table.MAX_TABLE_CAPACITY)
if start_time_mode == 'valid_past_contagion_time':
start_time = test_reservation.faker.date_time_between_dates(
datetime.utcnow() - timedelta(days=14), datetime.utcnow())
elif start_time_mode == 'valid_future_contagion_time':
start_time = test_reservation.faker.date_time_between(
'now', '+14d')
else:
start_time = TestReservation.faker.date_time_between('now', '+6w')
reservation = Reservation(user=user,
table=table,
restaurant=restaurant,
people_number=people_number,
start_time=start_time)
return reservation, (user, table, restaurant, start_time)
def test_retrieve_all_contact_reservation_by_id(self):
from gooutsafe.models.reservation import Reservation
from gooutsafe.models.table import Table
restaurant, _ = self.test_restaurant.generate_random_restaurant()
self.restaurant_manager.create_restaurant(restaurant=restaurant)
start_time_positive = datetime(year=2020, month=11, day=2, hour=11)
end_time_positive = start_time_positive + timedelta(
Reservation.MAX_TIME_RESERVATION)
contacted_users = []
for _ in range(0, self.faker.random_int(min=2, max=10)):
table, _ = self.test_table.generate_random_table(
fixed_restaurant=restaurant)
self.table_manager.create_table(table)
start_time = datetime(year=2020,
month=11,
day=2,
hour=self.faker.random_int(min=11, max=13),
minute=self.faker.random_int(min=0, max=59))
contacted_user = self.test_user.generate_random_user()
contacted_users.append(contacted_user)
self.user_manager.create_user(contacted_user)
reservation = Reservation(contacted_user, table, restaurant, 1,
start_time)
self.reservation_manager.create_reservation(reservation)
table1, _ = self.test_table.generate_random_table(
fixed_restaurant=restaurant)
positive_user = self.test_user.generate_random_user()
self.user_manager.create_user(positive_user)
positive_reservation = Reservation(positive_user, table1, restaurant,
1, start_time_positive)
self.reservation_manager.create_reservation(positive_reservation)
retrieved_contacted_reservations = self.reservation_manager.retrieve_all_contact_reservation_by_id(
positive_reservation.id)
retrieved_contacted_users = []
for res in retrieved_contacted_reservations:
retrieved_contacted_users.append(res.user)
retrieved_contacted_users.sort(
key=lambda positive_user: positive_user.id)
contacted_users.sort(key=lambda positive_user: positive_user.id)
for retrieved_contacted_user, contacted_user in zip(
retrieved_contacted_users, contacted_users):
self.test_user.assertUserEquals(contacted_user,
retrieved_contacted_user)
def test_retrieve_by_date_and_time(self):
from gooutsafe.models.reservation import Reservation
restaurant_id = self.faker.random_int(min=0, max=5000)
start_interval = datetime(year=2020, month=11, day=30, hour=0)
end_interval = start_interval + timedelta(hours=23)
reservations = []
for i in range(0, self.faker.random_int(min=1, max=10)):
table = self.faker.random_int(min=0, max=5000)
start_time = datetime(year=2020, month=11, day=30, hour=i + 1)
user = self.faker.random_int(min=0, max=5000)
reservation = Reservation(user, table, restaurant_id, 1,
start_time)
reservations.append(reservation)
self.reservation_manager.create_reservation(reservation)
retreived_res = self.reservation_manager.retrieve_by_date_and_time(
restaurant_id, start_interval, end_interval)
self.assertListEqual(reservations, retreived_res)
def edit_reservation(reservation_id):
"""Allows the customer to edit a single reservation,
if there's an available table within the opening hours
of the restaurant.
Linked to route reservation/{reservation_id} [PUT]
Args:
reservation_id (int): univocal identifier of the reservation
restaurant_id (int): univocal identifier of the restaurant
Returns:
Invalid request for wrong data or if the reservation doesn't exists
The json of the edited reservation
"""
try:
json_data = request.get_json()
start_time = json_data['start_time']
people_number = json_data['people_number']
tables = json_data['tables']
times = json_data['times']
old_reservation = ReservationManager.retrieve_by_id(reservation_id)
user_id = old_reservation.user_id
restaurant_id = old_reservation.restaurant_id
ReservationManager.delete_reservation(old_reservation)
table_id, start_time = validate_reservation(tables, times, start_time,
people_number)
if table_id is False:
ReservationManager.create_reservation(old_reservation)
raise ValueError
reservation = Reservation(user_id, table_id, restaurant_id,
people_number, start_time)
ReservationManager.create_reservation(reservation)
except Exception as e:
print("MUSCAAAAAAAAA")
return jsonify({
'status':
'Bad request',
'message':
'The data provided were not correct.\n' + str(e)
}), 400
return jsonify({
'status': 'Success',
'message': 'Reservation succesfully added'
}), 200
def test_retrieve_by_date_and_time(self):
from gooutsafe.models.reservation import Reservation
from gooutsafe.models.table import Table
restaurant, _ = self.test_restaurant.generate_random_restaurant()
self.restaurant_manager.create_restaurant(restaurant=restaurant)
start_interval = datetime(year=2020, month=11, day=30, hour=0)
end_interval = start_interval + timedelta(hours=23)
reservations = []
for i in range(0, self.faker.random_int(min=1, max=10)):
table, _ = self.test_table.generate_random_table(
fixed_restaurant=restaurant)
self.table_manager.create_table(table)
start_time = datetime(year=2020, month=11, day=30, hour=i + 1)
user = self.test_user.generate_random_user()
self.user_manager.create_user(user)
reservation = Reservation(user, table, restaurant, 1, start_time)
reservations.append(reservation)
self.reservation_manager.create_reservation(reservation)
retreived_res = self.reservation_manager.retrieve_by_date_and_time(
restaurant.id, start_interval, end_interval)
self.assertListEqual(reservations, retreived_res)
def test_validate_reservation_occupied_table(self):
from gooutsafe.resources.reservation import validate_reservation
from gooutsafe.models.reservation import Reservation
#Occupied tables
start = datetime.strptime('2020-11-30 12:00:00', "%Y-%m-%d %H:%M:%S")
reservation = Reservation(1, 1, 1, 2, start)
self.reservation_manager.create_reservation(reservation)
tables = []
tables.append({'id': 1, 'capacity': 2, 'restaurant_id': 1})
times = []
times.append({
'id': 1,
'start_time': '10:00:00',
'end_time': '15:00:00',
'day': 'Monday',
'restaurant_id': 1
})
start_datetime = '2020-11-30 12:00:00'
people_number = 1
self.assertFalse(
validate_reservation(tables, times, start_datetime, people_number))
self.reservation_manager.delete_reservation(reservation)