def search_tables(start_moment: datetime, end_moment: datetime, seat_count: int, tolerance=timedelta(minutes=30)) \
-> FINQ[Table]:
# if existing booking intersects with search more than in 30 minutes, then this table is dropped
return FINQ(db.session.query(Table)) \
.filter(lambda t: t.seat_count >= seat_count) \
.filter(lambda t: FINQ(t.bookings)
.filter(lambda b: datetime_segment_intersection(start_moment, end_moment, b.booking_start_datetime,
b.booking_end_datetime) > tolerance)
.none())
def search_all_tables():
start = datetime.strptime(request.args["startDatetime"], DATEFORMAT)
end = datetime.strptime(request.args["endDatetime"], DATEFORMAT)
seat_count = int(request.args["seatsCount"])
return {
Fields.Restaurants.value:
DatabaseController.search_all_tables(start, end, seat_count).group_by(
lambda t: t[0].restaurant_id).map(lambda l: FINQ(l).map(lambda t: (
t[0].restaurant_id, zip_table(t))).self(extract_key)).
map(lambda kl: (DatabaseController.get_restaurant(kl[0]), kl[1])).map(
zip_restaurant).to_list()
}
def get_table_with_bookings(table, start: datetime, end: datetime):
return quote_fields({
Fields.Id:
table.id,
Fields.SeatCount:
table.seat_count,
Fields.TableNumber:
table.table_number,
Fields.RestaurantId:
table.restaurant_id,
Fields.Bookings:
FINQ(table.bookings).filter(
datetime_segment_day_intersections(
start, end)).map(lambda b: b.id).map(get_booking).to_list()
})
def get_table_bookings(restaurant_identifier, table_number):
table = DatabaseController.get_table_from_number_and_restaurant(
table_number, restaurant_identifier)
if table:
return quote_fields({
Fields.Success:
True,
Fields.Bookings:
FINQ(
table.bookings).map(lambda b: b.id).map(get_booking).to_list()
})
else:
return quote_fields({
Fields.Success: False,
Fields.Error: Errors.NoTable
})
def get_tables_at_restaurant(identifier):
return FINQ(DatabaseController.get_restaurant(identifier).tables) \
.map(get_table) \
.to_dict(lambda d: d[Fields.Id.value], Identity)
def get_tables():
return FINQ(DatabaseController.get_tables()) \
.map(get_table) \
.to_dict(lambda d: d[Fields.Id.value], Identity)
def search_all_tables(start_moment: datetime, end_moment: datetime, seat_count: int, tolerance=timedelta(minutes=30)) \
-> FINQ[Tuple[Table, List[Booking]]]:
# if existing booking intersects with search more than in 30 minutes, then this table is dropped
return FINQ(db.session.query(Table)) \
.filter(lambda t: t.seat_count >= seat_count) \
.map(lambda t: (t, FINQ(t.bookings).filter(datetime_segment_day_intersections(start_moment, end_moment))))
def booking_intersects_others(table, start_time, end_time) -> bool:
return FINQ(table.bookings) \
.filter(datetime_segment_day_intersections(start_time, end_time)) \
.filter(lambda b: datetime_segment_intersection(start_time, end_time, b.booking_start_datetime,
b.booking_end_datetime).microseconds > 0).any()