def book_cage(account: Owner, cage: Cage, snake: Snake,
check_in_date: datetime.datetime,
check_out_date: datetime.datetime) -> Cage:
# find the booking
for b in cage.bookings:
if b.check_in_date <= check_in_date and \
b.check_out_date >= check_out_date and \
b.guest_snake_id is None:
booking = b
break
# create separate bookings for before/after this booking
if booking.check_in_date < check_in_date:
days = (check_in_date - booking.check_in_date).days
add_available_date(cage, booking.check_in_date, days)
if booking.check_out_date > check_out_date:
days = (booking.check_out_date - check_out_date).days
add_available_date(cage, check_out_date, days)
# update this booking with the reservation details
booking.guest_owner_id = account.id
booking.guest_snake_id = snake.id
booking.booked_date = datetime.datetime.now()
booking.check_in_date = check_in_date
booking.check_out_date = check_out_date
cage.save()
return
def num_cages_with_sufficient_space(snake_len):
min_size = snake_len / 4
# Use __ and operator name without $ to apply for query
cages = Cage.objects().filter(square_meters__gte=min_size)
# Count will return the number of matches rather than the documents
cage_count = Cage.objects(square_meters__gte=min_size).count()
return cage_count
def add_available_date(cage: Cage, start_date: datetime.datetime,
days: int): # -> Cage:
booking = Booking()
booking.check_in_date = start_date
booking.check_out_date = start_date + datetime.timedelta(days=days)
# cage = Cage.objects(id=cage.id.first())
cage.bookings.append(booking)
cage.save()
def add_available_date(cage: Cage,
start_date: datetime.datetime, days: int) -> Cage:
booking = Booking()
booking.check_in_date = start_date
booking.check_out_date = start_date + datetime.timedelta(days=days)
cage = Cage.objects(id=cage.id).first()
cage.bookings.append(booking)
cage.save()
return cage
def add_available_date(cage: Cage,
start_date: datetime.datetime, days: int) -> Cage:
booking = Booking()
booking.check_in_date = start_date
booking.check_out_date = start_date + datetime.timedelta(days=days)
cage = Cage.objects(id=cage.id).first() #get the cage
cage.bookings.append(booking) #booking is added to cage as it as embedded document
cage.save()
return cage
def add_date(cage: Cage, start_date: datetime.datetime, days: int):
booking = Booking()
booking.check_in_date = start_date
booking.check_out_date = start_date + datetime.timedelta(days=days)
cage = Cage.objects(id=cage.id).first()
cage.bookings.append(booking)
cage.save()
return cage
def book_cage(account: Owner, snake: Snake, cage: Cage,
checkin: datetime.datetime, checkout: datetime.datetime):
booking = None
for b in cage.bookings:
if b.check_in_date <= checkin and b.check_out_date >= checkout and b.guest_owner_id == None:
booking = b
booking.guest_owner_id = account.id
booking.guest_snake_id = snake.id
booking.booked_date = datetime.datetime.now()
cage.save()
def book_cage(account: Owner, snake: Snake, cage: Cage,
checkin: datetime.datetime, checkout: datetime.datetime):
booking = Booking()
booking.guest_owner_id = account.id
booking.guest_snake_id = snake.id
booking.booked_date = datetime.datetime.now()
booking.check_in_date = checkin
booking.check_out_date = checkout
cage = Cage.objects(id=cage.id).first()
cage.bookings.append(booking)
cage.save()
def register_cage(active_account: Owner, name, allow_dangerous, has_toys,
carpeted, metres, price) -> Cage:
cage = Cage()
cage.name = name
cage.square_metres = metres
cage.is_carpeted = carpeted
cage.has_toys = has_toys
cage.allow_dangerous_snakes = allow_dangerous
cage.price = price
cage.save()
active_account.cage_ids.append(cage.id)
active_account.save()
return cage
def find_cages_for_user(account: Owner) -> List[Cage]:
query = Cage.objects(
id__in=account.cage_ids) # find all cage ids in account.cage_ids
cages = list(query)
return cages
def get_available_cages(checkin: datetime.datetime,
checkout: datetime.datetime,
snake: Snake) -> List[Cage]:
min_size = snake.length / 4
query = Cage.objects() \
.filter(square_meters__gte=min_size) \
.filter(availabilities__from_date__lte=checkin) \
.filter(availabilities__to_date__gte=checkout)
if snake.is_venomous:
query = query.filter(allow_dangerous_snakes=True)
cages = query.order_by('price', '-square_meters')
final_cages = []
for c in cages:
booked = 0
for b in c.bookings:
if ((b.check_in_date <= checkin and b.check_out_date >= checkin)
or (b.check_in_date <= checkout
and b.check_out_date >= checkout)):
booked += 1
break
if (booked == 0):
final_cages.append(c)
return final_cages
def get_available_cages(
checkin: datetime, checkout: datetime, snake: Snake
) -> List[Cage]:
min_size = snake.length / 4
query = (
Cage.objects() # pylint: disable=no-member
.filter(square_meters__gte=min_size)
.filter(bookings__check_in_date__lte=checkin)
.filter(bookings__check_out_date__gte=checkin)
)
if snake.is_venomous:
query = query.filter(allow_dangerous_snakes=True)
cages = query.order_by("price", "-square_meters")
final_cages = []
for c in cages:
for b in c.bookings:
if (
b.check_in_date <= checkin
and b.check_out_date >= checkout
and b.guest_snake_id is None
):
final_cages.append(c)
return final_cages
def register_cage(active_account,name,price,allow_dangerous,has_toys,carpeted,meters) -> Cage:
cage = Cage()
cage.name = name
cage.square_meters = meters
cage.is_carpeted = carpeted
cage.has_toys = has_toys
cage.allow_dangerous_snakes = allow_dangerous
cage.price = price
cage.save() # stores it in the database
account = find_account_by_email(active_account.email) # we don't have any stale data
account.cage_ids.append(cage.id) #adding the new cage id
account.save() #push the changes back to database
return cage
def register_cage(active_account: Owner, name, allow_dangerous, has_toys,
carpeted, meters, price) -> Cage:
cage = Cage()
cage.name = name
cage.square_meters = meters
cage.is_carpeted = carpeted
cage.has_toys = has_toys
cage.allow_dangerous_snakes = allow_dangerous
cage.price = float(price)
cage.save() # asigna un id y guarda en la bd.
account = find_account_by_email(active_account.email)
account.cage_ids.append(cage.id)
account.save()
return cage
def register_cage(active_account: Owner, price, name, allow_dangerous,
has_toys, carpated, meters) -> Cage:
cage = Cage()
cage.name = name
cage.allow_dangerous_snakes = allow_dangerous
cage.is_carpeted = carpated
cage.has_toys = has_toys
cage.price = price
cage.square_meters = meters
cage.save() # must save the cage data first
account = find_account_by_email(active_account.email)
account.cage_ids.append(cage.id)
account.save()
return cage
def add_available_date(selected_cage, start_date, days):
booking = Booking()
booking.check_in_date = start_date
booking.check_out_date = start_date + datetime.timedelta(days=days)
cage = Cage.objects(id=selected_cage.id).first()
cage.bookings.append(booking)
cage.save()
def register_cage(active_account: Owner, name, allow_dangerous, has_toys,
carpeted, meters, price) -> Cage:
cage = Cage()
cage.name = name
cage.allow_dangerous = allow_dangerous
cage.has_toys = has_toys
cage.carpeted = carpeted
cage.meters = meters
cage.price = price
cage.save()
account = find_account_by_email(active_account.email)
account.cage_ids.append(cage.id)
account.save()
return cage
def register_cage(account: Owner, name: str, price: float, meters: float,
carpeted: bool, has_toys: bool,
allow_dangerous: bool) -> Cage:
cage = Cage()
cage.name = name
cage.price = price
cage.square_meters = meters
cage.carpeted = carpeted
cage.has_toys = has_toys
cage.allow_dangerous_snakes = allow_dangerous
cage.save()
account = find_account_by_email(account.email) # get fresh copy
account.cage_ids.append(cage.id)
account.save()
return cage
def add_available_date(cage: Cage, start_date: datetime.datetime,
days: int) -> Cage:
availability = Availability()
availability.from_date = start_date
availability.to_date = start_date + datetime.timedelta(
days=days) - datetime.timedelta(seconds=1)
cage = Cage.objects(id=cage.id).first()
try:
cage.availabilities[0] = availability
except:
cage.availabilities.append(availability)
cage.save()
return cage
def book_cage(account: Owner, snake: Snake, cage: Cage,
check_in_date: datetime.datetime,
checkout_date: datetime.datetime) -> Cage:
booking: Booking = None
for b in cage.bookings:
if b.check_in_date <= check_in_date and b.check_out_date >= checkout_date \
and not b.booked_date:
booking = b
break
booking.guest_owner_id = account.id
booking.guest_snake_id = snake.id
booking.booked_date = datetime.datetime.now()
cage.save()
return cage
def register_cage(
active_account: Owner, name, allow_dangerous, has_toys, carpeted, meters, price
) -> Cage:
cage = Cage()
cage.name = name
cage.square_meters = meters
cage.is_carpeted = carpeted
cage.has_toys = has_toys
cage.allow_dangerous_snakes = allow_dangerous
cage.price = price
cage.save()
account = find_account_by_email(active_account.email)
account.cage_ids.append(cage.id) # pylint: disable=no-member
account.save()
return cage
def register_cage(active_account: Owner, name: str, cost: float,
square_meters: float, is_carpented: bool, has_toys: bool,
allow_dangerous_snakes: bool) -> Cage:
cage = Cage()
cage.name = name
cage.cost = cost
cage.square_meters = square_meters
cage.is_carpented = is_carpented
cage.has_toys = has_toys
cage.allow_dangerous_snakes = allow_dangerous_snakes
cage.save()
owner = find_account_by_email(active_account.email)
owner.cage_ids.append(cage.id)
owner.save()
return cage
def register_cage(active_account: Owner, name, meters, is_carpeted, has_toys,
allow_dangerous_snakes, price):
cage = Cage()
cage.name = name
cage.price = price
cage.square_meters = meters
cage.is_carpeted = is_carpeted
cage.has_toys = has_toys
cage.allow_dangerous_snakes = allow_dangerous_snakes
cage.save()
account = find_account_by_email(active_account.email)
account.cage_ids.append(cage.id)
account.save()
return cage
def add_available_date(selected_cage: Cage, start_date: datetime, days: int) -> Cage:
booking = Booking()
booking.check_in_date = start_date
booking.check_out_date = start_date + timedelta(days=days)
cage = Cage.objects(id=selected_cage.id).first() # pylint: disable=no-member
cage.bookings.append(booking)
cage.save()
return cage
def book_cage(active_account: Owner, selected_snake: Snake, cage: Cage,
check_in_date: datetime.datetime,
check_out_date: datetime.datetime):
booking: Booking = None
for b in cage.bookings:
if b.check_in_date <= check_in_date \
and b.check_out_date >= check_out_date \
and b.guest_snake_id is None:
booking = b
break
booking.booked_date = datetime.datetime.now()
booking.check_in_date = check_in_date
booking.check_out_date = check_out_date
booking.guest_snake_id = selected_snake.id
booking.guest_owner_id = active_account.id
cage.save()
def register_cage(active_account: Owner,
name, allow_dangerous, has_toys, carpeted, meters, price) -> Cage:
cage = Cage()
cage.name = name
cage.square_meters = meters
cage.is_carpeted = carpeted
cage.has_toys = has_toys
cage.allow_dangerous_snakes = allow_dangerous
cage.price = price
# Must save before appending to list, otherwise blank id
cage.save()
# Makes sure account info is current and appends to cage_id list
account = find_account_by_email(active_account.email)
account.cage_ids.append(cage.id)
account.save()
return cage
def add_available_date(selectedcage: Cage, start_date: datetime.datetime,
duration: int):
booking = Booking()
booking.check_in_date = start_date
booking.check_out_date = start_date + datetime.timedelta(days=duration)
cage = Cage.objects(id=selectedcage.id).first()
cage.bookings.append(booking)
cage.save()
return cage
def register_cage(active_account: Owner, name: str, allow_angry: bool,
has_toys: bool, carpeted: bool, meters: float,
price: float) -> Cage:
cage = Cage()
cage.name = name
cage.square_meters = meters
cage.is_carpeted = carpeted
cage.has_toys = has_toys
cage.allow_angry_cats = allow_angry
cage.price = price
cage.save()
account, msg = find_account_by_email(active_account.email,
active_account.password)
account.cage_ids.append(cage.id)
account.save()
return cage
def register_cage(active_account: Owner,
name, allow_dangerous, has_toys,
carpeted, meters, price) -> Cage:
cage = Cage()
cage.name = name
cage.square_meters = meters
cage.is_carpeted = carpeted
cage.has_toys = has_toys
cage.allow_dangerous_snakes = allow_dangerous
cage.price = price
cage.save()
account = find_account_by_email(active_account.email)
account.cage_ids.append(cage.id)
account.save()
return cage
def get_bookings_for_user(user_id: bson.ObjectId) -> List[Booking]:
account = Owner.objects(id=user_id).first()
booked_cages = Cage.objects() \
.filter(bookings__guest_owner_id=account.id) \
.only('bookings', 'name')
def map_cage_to_booking(cage: Cage, booking: Booking) -> Booking:
booking.cage = cage
return booking
bookings = [
map_cage_to_booking(c, booking) for c in booked_cages
for booking in c.bookings if booking.guest_owner_id == account.id
]
return bookings
def find_bookings_for_user(account: Owner) -> List[Booking]:
account = find_account_by_email(account.email) # get fresh copy
booked_cages = Cage.objects() \
.filter(bookings__guest_owner_id=account.id) \
.only('bookings', 'name')
def map_cage_to_booking(booking, cage):
booking.cage = cage
return booking
bookings = [
map_cage_to_booking(booking, cage) for cage in booked_cages
for booking in cage.bookings if booking.guest_owner_id == account.id
]
return bookings
def get_bookings_for_user(account: Owner) -> List[Booking]:
booked_cages = Cage.objects() \
.filter(bookings__guest_owner_id=account.id) \
.only('bookings', 'name')
def map_cage_to_booking(cage, booking):
booking.cage = cage
return booking
bookings = [
map_cage_to_booking(cage, booking) for cage in booked_cages
for booking in cage.bookings if booking.guest_owner_id == account.id
]
return bookings
def get_bookings_for_user(email: str) -> List[Booking]:
account = find_account_by_email(email)
booked_cages = Cage.objects() \
.filter(bookings__guest_owner_id=account.id) \
.only('bookings', 'name')
def map_cage_to_booking(cage, booking):
booking.cage = cage
return booking
bookings = [
map_cage_to_booking(cage, booking)
for cage in booked_cages
for booking in cage.bookings
if booking.guest_owner_id == account.id
]
return bookings
def get_available_cages(checkin: datetime.datetime,
checkout: datetime.datetime, snake: Snake) -> List[Cage]:
min_size = snake.length / 4
query = Cage.objects() \
.filter(square_meters__gte=min_size) \
.filter(bookings__check_in_date__lte=checkin) \
.filter(bookings__check_out_date__gte=checkout)
if snake.is_venomous:
query = query.filter(allow_dangerous_snakes=True)
cages = query.order_by('price', '-square_meters')
final_cages = []
for c in cages:
for b in c.bookings:
if b.check_in_date <= checkin and b.check_out_date >= checkout and b.guest_snake_id is None:
final_cages.append(c)
return final_cages
def find_cages_for_user(account: Owner) -> List[Cage]:
query = Cage.objects(id__in=account.cage_ids)
cages = list(query)
return cages
