def booking_new():
current_user = get_jwt_identity()
if get_jwt_header()['type'] == "User":
response = request.get_json()
user = User.get_or_none(User.email == current_user)
new_booking = Booking(user=user.id, chef=response['chef'], address=response['address'], service_type=response['service_type'], pax=response['pax'], meal_type=response['meal_type'], menu_type=response['menu_type'], hob_type=response['hob_type'], no_of_hob=response['no_of_hob'], oven=response['oven'], price=response['price'], diet_restrictions=response['diet_restrictions'], proposed_date=response['proposed_date'], message=response['message'], completed=False, payment_status=False, confirmed=False, active=True, cancelled=False)
if new_booking.save():
return jsonify({
"message": "Successfully created new booking",
"status": "success",
"booking_id": new_booking.id,
"chef_id": new_booking.chef_id,
"user_id": new_booking.user_id,
"completed":new_booking.completed,
"payment_status":new_booking.payment_status,
"confirmed":new_booking.confirmed,
"active":new_booking.active,
"cancelled":new_booking.cancelled
}), 200
else:
return jsonify({
"message": "failed to create new booking",
"status": "failed"
}), 400
else:
return jsonify(message="You are logged in as Chef, not User ", status="success"), 400
def create_booking():
fitness_class = fitness_class_repository.select(
request.form['fitness_class_id'])
member = member_repository.select_by_membership_no(
request.form['membership_no'])
id = request.form['fitness_class_id']
class_type = fitness_class.class_type
date = fitness_class.date
time = fitness_class.time
duration = fitness_class.duration
instructor = fitness_class.instructor
location = fitness_class.location
class_participants = fitness_class_repository.get_participants(
fitness_class)
for participant in class_participants:
if participant.id == member.id:
return redirect('/bookings/member-already-booked')
if fitness_class.capacity > 0:
capacity = fitness_class.capacity - 1
fitness_class = FitnessClass(class_type, date, time, duration,
instructor, capacity, location, id)
fitness_class_repository.edit(fitness_class)
new_booking = Booking(member, fitness_class)
booking_repository.add(new_booking)
return redirect('/bookings')
else:
return redirect('/bookings/class-full')
def booking_add(self):
print(Fore.RED, " Add Booking ".center(30, "*"), Fore.RESET)
guest = Guest_service()
guest_id = guest.search_guest()
Apartments = Apartment_service()
apartments = Apartments.search_apartment()
rowIdx = get_int("Please select apt number: ", 0, len(apartments))
apartment = apartments[rowIdx]
apartment_price = apartment.price
booking = Booking()
booking.guest_id = guest_id
booking.booked_date = datetime.datetime.now()
booking.chek_in_date = get_date("Input Data")
booking.chek_out_date = get_date("Input Data")
if (apartments == None or len(apartments) == 0):
print("Error")
return
apartment.bookings.append(booking)
apartment.save()
columns = ("Chek_in_date", "Chek_out_date", "Booked_date")
pretty_print([booking], columns)
print("{}Booking duration is {} day(s).{}".format(Fore.YELLOW, booking.duration, Fore.RESET))
print("{}TOTAL Price {} USD.{}".format(Fore.YELLOW, apartment_price * booking.duration, Fore.RESET))
print(Fore.RED, " Apartment Saved".center(30, "*"), Fore.RESET)
def book():
data = {}
name = request.form['name']
mobile = request.form['mobile']
date_input = request.form['date']
time = request.form['time']
timestamp = date_input + " " + time
datetimeformat = dt.datetime.strptime(timestamp, '%d-%m-%Y %I:%M %p')
user = User.get_or_none(User.mobile_num == mobile)
bookSlotValidate = Booking.select().where(Booking.booking_time == datetimeformat)
if len(bookSlotValidate) > 0:
slot_booked = check_slot_available(datetimeformat,[slot.booking_time for slot in bookSlotValidate])
if slot_booked == 0:
res = make_response(jsonify('Slot was Booked by Other user'),422)
return res
booking = Booking(booking_time = datetimeformat, user = user , slot =1 )
booking.save()
data['name'] = name
data['mobile'] = mobile
data['booking_time'] = datetimeformat
# return redirect('users/new.html')
res = make_response(jsonify(data),200)
return res
def post(self, args):
## Check if the Timetable already exists
timetable = Timetable.query.filter_by(name=args['timetable']).first()
if timetable is None:
abort(404, message='Timetable not found')
## Check the start date and end date of the session is the same
if args['start'].date() != args['end'].date():
abort(422, message="Start and End date must match")
## Check the end time is after the start time
if args['start'].time() >= args['end'].time():
abort(422, message="The session must end after its start time")
## Strip timezone data if its present
args['start'] = args['start'].replace(tzinfo=None)
args['end'] = args['end'].replace(tzinfo=None)
## Conflict check
isConflicting = timetable.checkBookingConflict(args['start'], args['end'])
if isConflicting:
abort(422, message="Booking Conflict, A sessions already exists at this time")
## Parse the parameters to a dictionary for SQLAlchemy
bookingData = {}
bookingData['name'] = args['name']
bookingData['start'] = args['start']
bookingData['end'] = args['end']
bookingData['cell_colour'] = args['colour']
## Create the booking object
booking = Booking(**bookingData)
booking.timetable_id = timetable.identifier ## Set the bookings timetable to the found supplied one
db.session.add(booking)
db.session.commit()
return "", 201
def create_booking():
member_id = request.form['member_id']
workout_id = request.form['workout_id']
member = member_repository.select(member_id)
workout = workout_repository.select(workout_id)
booking = Booking(member, workout)
booking_repository.save(booking)
return redirect('/members')
def select(id):
sql = "SELECT * FROM bookings WHERE id = %s"
value = [id]
result = run_sql(sql, value)[0]
member = member_repository.select(result['member_id'])
fitness_class = fitness_class_repository.select(result['fitness_class_id'])
booking = Booking(member, fitness_class, result['id'])
return booking
def select(id):
sql = "SELECT * FROM bookings WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
workout = workout_repository.select(result["workout_id"])
member = member_repository.select(result["member_id"])
booking = Booking(workout, member, result["id"])
return booking
def add_booking():
member_id = request.form["member_id"]
session_id = request.form["session_id"]
member = member_repository.select(member_id)
session = session_repository.select(session_id)
booking = Booking(member, session)
booking_repository.save(booking)
return redirect("/bookings")
def create_booking():
member_id = request.form["member_id"]
session_id = request.form["session_id"]
member = member_repo.select(member_id)
session = session_repo.select(session_id)
new_booking = Booking(member, session)
booking_repo.save(new_booking)
return redirect("/bookings")
def setUp(self):
self.member_1 = Member("Dario", "Cologna", "male", 34)
self.date = datetime.date(2020, 12, 16)
self.time = datetime.time(6, 15)
self.workout_1 = Workout("Just Skate", "freestyle", self.date,
self.time, 3)
self.booking_1 = Booking(self.member_1, self.workout_1)
def update_booking(id):
workout_id = request.form["workout_id"]
member_id = request.form["member_id"]
workout = workout_repository.select(workout_id)
member = member_repository.select(member_id)
booking = Booking(workout, member, id)
booking_repository.update(booking)
return redirect("/bookings")
def create_booking():
workout_id = request.form["workout_id"]
member_id = request.form["member_id"]
workout = workout_repository.select(workout_id)
member = member_repository.select(member_id)
new_booking = Booking(workout, member)
booking_repository.save(new_booking)
return redirect("/bookings")
def create_task():
member_id = request.form['member_id']
session_id = request.form['session_id']
member = member_repository.select(member_id)
session = session_repository.select(session_id)
booking = Booking(member, session)
booking_repository.save(booking)
return redirect('/bookings')
def update_booking(id):
member_id = request.form["member_id"]
session_id = request.form["session_id"]
member = member_repo.select(member_id)
session = session_repo.select(session_id)
booking = Booking(member, session, id)
booking_repo.update(booking)
return redirect("/bookings")
def create_booking():
member_id = request.form['member_id']
lesson_id = request.form['lesson_id']
member = member_repository.select(member_id)
lesson = lesson_repository.select(lesson_id)
booking = Booking(member, lesson)
booking_repository.save(booking)
return redirect('/bookings')
def select(id):
sql = 'SELECT * FROM bookings WHERE id = %s'
values = [id]
results = run_sql(sql, values)[0]
member = member_repository.select(results['member_id'])
activity = activity_repository.select(results['activity_id'])
booking = Booking(member, activity, results['note'], results['id'])
return booking
def confirm_booking():
member_id = request.form['member_id']
gymsession_id = request.form['gymsession_id']
member = member_repository.view(member_id)
gymsession = gymsession_repository.view(gymsession_id)
new_booking = Booking(member, gymsession)
booking_repository.add_new(new_booking)
return render_template('bookings/confirm_booking.html')
def add_booking():
member_id = request.form["member"]
gym_class_id = request.form["gym_class"]
booked_gym_class = gym_class_repository.select(gym_class_id)
booked_member = member_repository.select(member_id)
booking = Booking(booked_member, booked_gym_class)
booking_repository.save(booking)
return redirect("/bookings")
def create_booking():
member_id = request.form["member_id"]
lesson_id = request.form["lesson_id"]
member = member_repository.select(member_id)
lesson = lesson_repository.select(lesson_id)
new_booking = Booking(member, lesson)
booking_repository.save(new_booking)
return redirect("/bookings")
def update_booking(id):
member_id = request.form["member_id"]
activity_id = request.form["activity_id"]
member = member_repository.select(member_id)
activity = activity_repository.select(activity_id)
booking = Booking(member, activity, id)
booking_repository.update(booking)
return redirect("/bookings")
def select(id):
sql = "SELECT * FROM fitness_class_member_bookings WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
if result is not None:
booking = Booking(result['member_id'], result['fitness_class_id'],
result['id'])
return booking
def select(id):
sql = "SELECT * FROM bookings WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
member = member_repository.select(result["member_id"])
session = session_repository.select(result["session_id"])
booking = Booking(member, session, result["id"])
return booking
def select(id):
sql = 'SELECT * FROM bookings WHERE id = %s'
values = [id]
result = run_sql(sql, values)[0]
member = member_repository.select(result['member_id'])
lesson = lesson_repository.select(result['lesson_id'])
booking = Booking(member, lesson, result['id'])
return booking
def select_all():
bookings = []
sql = "SELECT * FROM bookings"
results = run_sql(sql)
for result in results:
booking = Booking(result["member"], result["activity"], result["id"])
bookings.append(booking)
return members
def __map_selected_record_to_booking(record):
if record is None:
return None
else:
id, passenger_id, flight_id, booking_type, flight_class, booking_no, booking_date, seat_no, created_at = record
booking = Booking(id, passenger_id, flight_id, booking_type,
flight_class, booking_no, booking_date, seat_no,
created_at)
return booking
def select(id):
sql = "SELECT * FROM bookings WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
if result is not None:
member = member_repository.select(result["member_id"])
activity = activity_repository.select(result["activity_id"])
booking = Booking(member, activity, result["id"])
return booking
def setUp(self):
classdate = datetime.date(2020, 1, 1)
classtime = datetime.time(13, 0, 0)
self.gym_class1 = GymClass("Yoga", classdate, classtime, 10, 60)
start_date = datetime.date(2020, 1, 1)
self.member1 = Member("John", "Smith", "standard", start_date, True)
self.booking1 = Booking(self.member1, self.gym_class1)
def select(id):
booking = None
sql = "SELECT * FROM bookings WHERE id = %s"
values = [id]
result = run_sql(sql, values)[0]
if result is not None:
booking = Booking(result['member_id'], result['lesson_id'], result['id'])
return booking
def generate_bookings(user_list, item_list):
return[
Booking(
owner_id=user_list[0].id,
borrower_id=user_list[1].id,
item_id=item_list[0].id,
start_date=date.today(),
end_date=date.today()+timedelta(days=10),
owner_decision=True,
borrower_decision=True,
approval_status=True
),
Booking(
owner_id=user_list[1].id,
borrower_id=user_list[3].id,
item_id=item_list[1].id,
start_date=date.today(),
end_date=date.today()+timedelta(days=5),
owner_decision=True,
borrower_decision=True,
approval_status=True
),
Booking(
owner_id=user_list[3].id,
borrower_id=user_list[1].id,
item_id=item_list[1].id,
start_date=date.today(),
end_date=date.today()+timedelta(days=5),
owner_decision=True,
borrower_decision=True,
approval_status=True
),
Booking(
owner_id=user_list[0].id,
borrower_id=user_list[1].id,
item_id=item_list[2].id,
start_date=date.today(),
end_date=date.today()+timedelta(days=20),
owner_decision=True,
borrower_decision=True,
approval_status=True
)
]