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 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 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 approved_bookings():
# Returns approved orders by Chef
if get_jwt_header()['type'] == "Chef":
current_chef = Chef.get_or_none(Chef.username == get_jwt_identity())
bookings = Booking.select().where(Booking.chef_id == current_chef.id,
Booking.active == True,
Booking.confirmed == True)
if bookings:
return jsonify({
"count":
bookings.count(),
"results": [
{
# not complete information
"booking_id": booking.id,
"user_id": booking.user_id,
"chef_id": booking.chef_id,
"price": booking.price,
"proposed_date": booking.proposed_date,
"booking_completed": booking.completed,
"booking_confirmed": booking.confirmed,
"booking_active": booking.active,
} for booking in bookings
]
})
else:
return jsonify({
"message": "There are no confirmed bookings for this chef",
"status": "Failed"
}), 400
# Returns confirmed bookings for User
else:
current_user = User.get_or_none(User.username == get_jwt_identity())
bookings = Booking.select().where(Booking.user_id == current_user.id,
Booking.active == True,
Booking.confirmed == True)
if bookings:
return jsonify({
"count":
bookings.count(),
"results": [
{
# not complete information
"booking_id": booking.id,
"user_id": booking.user_id,
"chef_id": booking.chef_id,
"price": booking.price,
"proposed_date": booking.proposed_date,
"booking_completed": booking.completed,
"booking_confirmed": booking.confirmed,
"booking_active": booking.active,
} for booking in bookings
]
})
else:
return jsonify({
"message": "There are no confirmed bookings for this user",
"status": "Failed"
}), 400
async def create_booking(booking: Booking_Model, db: Session = Depends(get_db)):
booking = Booking.get_booking_by_email_and_date(db, booking.email, booking.date, booking.trailhead_id)
if booking:
raise HTTPException(status_code=400,
detail="A booking for this date and email already exists.")
new_booking = Booking.create(booking)
new_booking.save()
return booking
def booking(teacher_id, weekday, time):
form = forms.BookingForm()
if request.method == 'POST':
if form.validate_on_submit():
Booking.add(teacher=Teacher.query.get(teacher_id),
**form.data).commit()
return render_template("booking_done.html", form=form)
return render_template("booking.html",
teacher=Teacher.query.get(teacher_id),
weekday=weekday,
time=time,
form=form)
class TestBooking(unittest.TestCase):
def setUp(self):
self.member1 = Member('Diana', 'Prince', 'Premium', 'Active', 1)
self.member2 = Member('Bruce', 'Wayne', 'Premium', 'Inactive', 2)
self.member3 = Member('Peter', 'Parker', 'Standard', 'Active', 3)
self.gymsession1 = Gymsession('Les Mills - Body Pump',
'A full body weights workout.',
'Strength', 'Moderate', 'Monday',
'05/04/21', '13.00', 45, 'Peak', 'Gym 1',
4.50, 10, 'Lonnie Machin')
self.gymsession2 = Gymsession(
'Les Mills - Body Combat',
'High energy martial arts inspired workout.', 'Cardio', 'Advanced',
'Wednesday', '07/04/21', '15.00', 60, 'Off Peak', 'Gym 2', 4.50,
10, 'Selina Kyle', 2)
self.gymsession3 = Gymsession(
'Les Mills - Body Balance',
'A Yoga based class that will improve your mind, your body and your life',
'Flexibility', 'Beginner', 'Friday', '09/04/21', '11.00', 90,
'Peak', 'Gym 2', 4.50, 15, 'Selina Kyle', 3)
self.booking1 = Booking(self.member1.id, self.gymsession3.id)
self.booking2 = Booking(self.member2.id, self.gymsession1.id, True, 2)
self.booking3 = Booking(self.member2.id, self.gymsession3.id, True, 3)
def test_booking_has__booking_id(self):
self.assertEqual(None, self.booking1.id)
self.assertEqual(2, self.booking2.id)
self.assertEqual(3, self.booking3.id)
def test_booking_has__member_id(self):
self.assertEqual(1, self.booking1.member_id)
self.assertEqual(2, self.booking2.member_id)
self.assertEqual(2, self.booking3.member_id)
def test_booking_has__gymsession_id(self):
self.assertEqual(3, self.booking1.gymsession_id)
self.assertEqual(None, self.booking2.gymsession_id)
self.assertEqual(3, self.booking3.gymsession_id)
def test_booking_has__attendance(self):
self.assertEqual(False, self.booking1.attended)
self.assertEqual(True, self.booking2.attended)
self.assertEqual(True, self.booking3.attended)
def test_mark_class_as_attended(self):
self.booking1.add_attendance()
self.assertEqual(True, self.booking1.attended)
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 chef_approve(booking_id):
if get_jwt_header()['type'] == "Chef":
current_chef = Chef.get_or_none(Chef.email == get_jwt_identity())
booking = Booking.get_or_none(Booking.id == booking_id)
if booking:
if booking.chef_id == current_chef.id:
booking.confirmed = True
if booking.save():
return jsonify({
"booking_id": booking_id,
"completed": booking.completed,
"payment_status": booking.payment_status,
"confirmed": booking.confirmed,
"active": booking.active,
"cancelled": booking.cancelled,
"status": "success"
}), 200
else:
return jsonify({
"message": "You are logged in as another chef",
"booking_chef_id": booking.chef_id,
"status": "failed"
}), 400
else:
return jsonify({
"message": "Booking does not exist",
"status": "Failed"
}), 400
else:
return jsonify({
"message": "You have to log in as Chef, not user",
"status": "Failed"
}), 400
def booking_id(booking_id):
booking = Booking.get_or_none(Booking.id == booking_id)
if booking:
return jsonify({
"booking_id": booking.id,
"user": booking.user_id,
"chef": booking.chef_id,
"address": booking.address,
"service_type": booking.service_type,
"pax": booking.pax,
"meal_type": booking.meal_type,
"menu_type": booking.menu_type,
"hob_type": booking.hob_type,
"no_of_hob": booking.no_of_hob,
"oven": booking.oven,
"price": booking.price,
"diet_restrictions": booking.diet_restrictions,
"proposed_date": booking.proposed_date,
"message": booking.message,
"completed": booking.completed,
"payment_status": booking.payment_status,
"confirmed": booking.confirmed,
"active": booking.active,
"cancelled": booking.cancelled
}), 200
else:
return jsonify({
"message": "This booking does not exist",
"status": "Failed"
}), 400
def create(self, booking: Booking):
cursor = self.db.cursor()
sql = "INSERT INTO bookings(flight_id, passenger_id, flight_class, date, booking_ref, seat_number) VALUES ( %s, %s, %s, %s, %s, %s)"
val = (booking.flight_id, booking.passenger_id, booking.flight_class,
booking.date, booking.booking_ref, booking.seat_number)
cursor.execute(sql, val)
self.db.commit()
booking.id = cursor.lastrowid
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 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 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 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 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'])
lesson = lesson_repository.select(result['lesson_id'])
booking = Booking(member, lesson, result['id'])
return booking
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 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 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 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]
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 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 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 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 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')