def check_bookings_count(when, room_id):
room_count = Booking.select().join(Room).where(
(Booking.when == when) &
(Room.id == room_id)
).count()
room_check = False
if room_count < POP_LIMIT_ROOM:
room_check = True
room = Room.get(Room.id == room_id)
floor_count = Booking.select().join(Room).where(
(Booking.when == when) &
(Room.floor == room.floor) &
(Room.building == room.building)
).count()
floor_check = False
if floor_count < POP_LIMIT_FLOOR:
floor_check = True
building_count = Booking.select().join(Room).where(
(Booking.when == when) &
(Room.building == room.building)
).count()
building_check = False
if building_count < POP_LIMIT_BUILDING:
building_check = True
count_check = room_check*floor_check*building_check
return count_check, [room_check, floor_check, building_check]
def check_bookings_count(when, room_id, status='approved'):
assert status in ['approved', 'pending', 'denied']
room_count = Booking.select().join(Room).where((Booking.when == when) & (
Room.id == room_id) & (Booking.status == status)).count()
room_check = False
if room_count < POP_LIMIT_ROOM:
room_check = True
room = Room.get(Room.id == room_id)
floor_count = Booking.select().join(
Room).where((Booking.when == when) & (Room.floor == room.floor)
& (Room.building == room.building)
& (Booking.status == status)).count()
floor_check = False
if floor_count < POP_LIMIT_FLOOR:
floor_check = True
building_count = Booking.select().join(
Room).where((Booking.when == when) & (Room.building == room.building)
& (Booking.status == status)).count()
building_check = False
if building_count < POP_LIMIT_BUILDING:
building_check = True
count_check = room_check * floor_check * building_check
return bool(count_check), [room_check, floor_check, building_check]
def stats_occupation_around(when, room_id):
same_building_occupation = {}
same_building_occupation_rel = {}
same_floor_occupation = {}
same_floor_occupation_rel = {}
room = Room.get(Room.id == room_id)
same_building_occupation = Booking.select().join(Room).where(Booking.when == when, Room.building == room.building).count()
same_building_occupation_rel = same_building_occupation/POP_LIMIT_BUILDING
same_floor_occupation = Booking.select().join(Room).where(Booking.when == when, Room.building == room.building, Room.floor == room.floor).count()
same_floor_occupation_rel = same_floor_occupation/POP_LIMIT_FLOOR
return same_building_occupation, same_floor_occupation, same_building_occupation_rel, same_floor_occupation_rel
def get_bookings_of_user(user_id):
query = Booking.select().where(Booking.who == user_id)
user_bookings = [model_to_dict(c) for c in query]
for b in user_bookings:
booking = Booking.get(Booking.id == b['id'])
room = Room.get(Room.id == booking.room)
same_floor_occupation = Booking.select().join(Room).where(
Booking.when == booking.when, Room.building == room.building,
Room.floor == room.floor).count()
same_floor_occupation_rel = same_floor_occupation / POP_LIMIT_FLOOR * 100
b['value_abs'] = same_floor_occupation
b['value_rel'] = same_floor_occupation_rel
return user_bookings
def stats_occupation(when):
floor_occupation = {}
floor_occupation_rel = {}
building_occupation = {}
building_occupation_rel = {}
rows = Room.select(Room.building).group_by(Room.building)
buildings_of_the_campus = [row.building for row in rows]
for building in buildings_of_the_campus:
floor_occupation[building] = {}
floor_occupation_rel[building] = {}
rooms_of_the_building = Room.select().where(Room.building == building)
rows = Room.select(
Room.floor).where(Room.building == building).group_by(Room.floor)
floors_of_the_building = [row.floor for row in rows]
for floor in floors_of_the_building:
floor_occupation[building][floor] = 0
floor_occupation_rel[building][floor] = 0
day_occupation = Booking.select().where(Booking.when == when,
Booking.status == 'approved')
for booking in day_occupation:
room_id = booking.room
room = Room.get(Room.id == room_id)
floor_occupation[room.building][room.floor] += 1
floor_occupation_rel[room.building][room.floor] = floor_occupation[
room.building][room.floor] / POP_LIMIT_FLOOR
for building in floor_occupation:
building_occupation[building] = sum(
floor_occupation[building].values())
building_occupation_rel[
building] = building_occupation[building] / POP_LIMIT_BUILDING
return building_occupation, floor_occupation, building_occupation_rel, floor_occupation_rel
def processEdit(id, eventName, discountPercent, discountAmount, contact,
rooms):
"""Save the form data into a booking"""
b = Booking.select().where(Booking.id == id).get()
food = {}
for field in request.form:
if field.startswith('dish_'):
food[int(field.replace('dish_', ''))] = int(request.form[field])
b.eventName = eventName
b.discountPercent = discountPercent
b.discountAmount = discountAmount
b.contact_id = contact
rooms = Room.select().where(Room.id << rooms).execute()
if Room.areRoomsFree(rooms, b.startTime, b.endTime, id):
BookingRoom.delete().where(BookingRoom.booking == b).execute()
for room in rooms:
br = BookingRoom(booking=b, room=room)
br.save()
Order.delete().where(Order.booking == b).execute()
for f in food:
if food[f] > 0:
Order(dish=Dish.get(Dish.id == int(f)),
booking=b,
quantity=food[f]).save()
b.calculateTotal()
b.save()
else:
flash(
'A room that you selected is no longer available. Please select a new room.',
'error')
return redirect(request.referrer)
flash('Booking Updated', 'success')
return redirect(url_for('bookings.index'))
def get_pending_bookings_new(sort_by='booking_id'):
query = Booking.select().where(Booking.status == 'pending')
if sort_by == 'when':
query_sorted = query.order_by(Booking.when)
else:
query_sorted = query
pending_bookings = [model_to_dict(c) for c in query_sorted]
for b in pending_bookings:
booking = Booking.get(Booking.id == b['id'])
same_room_pending = Booking.select().join(Room).where(
Booking.when == booking.when, Booking.status == 'pending',
Room.id == booking.room).count()
if same_room_pending == 1:
b['unique_request'] = True
else:
b['unique_request'] = False
return pending_bookings
def get_pending_bookings(sort_by='booking_id'):
query = Booking.select().where(Booking.status == 'pending')
if sort_by == 'when':
query_sorted = query.order_by(Booking.when)
else:
query_sorted = query
pending_bookings = [model_to_dict(c) for c in query_sorted]
return pending_bookings
def get_floor_count(when, room_id, status='approved'):
assert status in ['approved', 'pending', 'denied']
room = Room.get(Room.id == room_id)
floor_count = Booking.select().join(
Room).where((Booking.when == when) & (Room.floor == room.floor)
& (Room.building == room.building)
& (Booking.status == status)).count()
return floor_count
def index(start=None, end=None):
"""Lists all bookings"""
if start is None:
start = date.today()
if end is None:
end = date.today() + timedelta(days=30)
b = Booking.select().where((Booking.startTime > start)
& (Booking.startTime < end)
& (Booking.isCanceled == False))
bookings = prefetch(b, BookingRoom, Room)
return render_template('bookings/index.html',
bookings=bookings,
start=start,
end=end)
def contactindex(cid, includeCanceled=True, start=None, end=None):
"""List all bookings for a contact"""
contact = Contact.select().where(Contact.id == cid).get()
if start is None:
start = date.today()
if end is None:
end = date.today() + timedelta(days=30)
b = (Booking.select(Booking).where(
Booking.contact == contact).where((Booking.startTime > start)
& (Booking.endTime < end)))
if not includeCanceled:
b = b.where(Booking.isCanceled == False)
bookings = prefetch(b, BookingRoom, Room, Contact)
return render_template('bookings/contactIndex.html',
bookings=bookings,
start=start,
end=end,
includeCanceled=includeCanceled,
contact=contact)
def check_bookings_of_user_room_when(user_id,
room_id,
when,
status='approved'):
assert status in ['approved', 'pending', 'denied']
# print(when)
# print(status)
# print('user_id', user_id)
# print('room_id', room_id)
query = Booking.select().join(Room).where((Booking.who == user_id)
& (Room.id == room_id)
& (Booking.when == when)
& (Booking.status == status))
count = query.count()
# print(count)
# if count > 0:
# print('peow')
# print(query[0].status)
assert count in [0, 1]
return bool(count)
def orgindex(orgid, includeCanceled=True, start=None, end=None):
"""List all bookings for an organization"""
if start is None:
start = date.today()
if end is None:
end = date.today() + timedelta(days=30)
b = (Booking.select(Booking).join(Contact).where(
Contact.organization_id == orgid).where((Booking.startTime > start)
& (Booking.endTime < end)))
if not includeCanceled:
b = b.where(Booking.isCanceled == False)
if orgid != 0:
org = Organization.select().where(Organization.id == orgid).get()
else:
org = Organization(name="No Organization")
bookings = prefetch(b, BookingRoom, Room, Contact)
return render_template('bookings/orgIndex.html',
bookings=bookings,
start=start,
end=end,
includeCanceled=includeCanceled,
org=org)
def edit(id):
"""Display a form to edit a booking"""
b = Booking.select().where(Booking.id == id)
booking = prefetch(b, Order, Dish, Caterer, Contact, Organization,
BookingRoom, Room, User)[0]
dishes = prefetch(Dish.select().where(Dish.isDeleted == False),
Caterer.select().where(Caterer.isDeleted == False))
orgs = Organization.select().where((Organization.isDeleted == False) | (
Organization.id == booking.contact.organization_id))
cons = Contact.select().where((Contact.isDeleted == False)
| (Contact.id == booking.contact_id))
print(booking.startTime, booking.endTime, type(booking.endTime))
rooms = Room.openRooms(booking.startTime, booking.endTime,
booking.id).execute()
contactjson = {}
for c in cons:
oid = c.organization_id if c.organization_id is not None else 0
if oid not in contactjson:
contactjson[oid] = {}
contactjson[oid][c.id] = c.name
roomjson = {}
for room in rooms:
roomjson[room.id] = {
'capacity': room.capacity,
'rate': float(room.price),
'adjacentRooms': room.adjacentRoomIds(),
'name': room.name,
'id': room.id
}
return render_template('bookings/edit.html',
booking=booking,
dishes=dishes,
orgs=orgs,
contacts=cons,
contactjson=contactjson,
rooms=rooms,
roomjson=roomjson)
def canceledData(start, end):
b = Booking.select().where((Booking.startTime > start)
& (Booking.startTime < end)
& (Booking.isCanceled == True))
return prefetch(b, BookingRoom, Room)
def view(id):
"""Display details of a single booking"""
b = Booking.select().where(Booking.id == id)
booking = prefetch(b, Order, Dish, Caterer, Contact, Organization,
BookingRoom, Room, User)[0]
return render_template('bookings/view.html', booking=booking)
def processCancel(id, reason):
"""Actually cancel (softDelete) a booking"""
Booking.select().where(Booking.id == id).get().delete(g.User.id,
reason).save()
flash('Booking Canceled', 'success')
return redirect(url_for('bookings.index'))
def cancel(id):
"""Dispaly a form to cancel a booking"""
booking = Booking.select().where(Booking.id == id).get()
return render_template('bookings/cancel.html', booking=booking)
def get_bookings_of_room(room_name):
query = Booking.select().join(Room).where(Room.name == room_name)
room_bookings = [model_to_dict(c) for c in query]
return room_bookings
def get_bookings_of_user_old(user_id):
query = Booking.select().where(Booking.who == user_id)
user_bookings = [model_to_dict(c) for c in query]
return user_bookings
def print_bookings():
''' Prints all bookings in terminal. '''
q = Booking.select()
for b in q:
print(b.id, b.who, b.when, b.room.name)
