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 book_appointment(request): # check if the request is of type post and if the user is Donor if request.method == 'POST' and request.user.is_donor: # get the required format of the data appointment = request.POST['time'] donor_id = request.POST['donor'] hospital_id = request.POST['hospital'] data = { 'hospital': Hospital.objects.get(pk=hospital_id), 'donor': Donor.objects.get(pk=donor_id), 'appointment': request.POST.get("time") } # Try to create a new Booking with provided data try: booking = Booking() booking.new_appointment(data) return JsonResponse({ 'success': True, 'message': "The appointment has been created successfully" }) except: return JsonResponse({ 'success': False, 'message': "You might have booking at this time at different hospital. Please, try different slot." }) else: return redirect("app:app")
def register_booking(self, model: RegisterBookingDto): booking = Booking() booking.flight_id = model.flight_id booking.passenger_id = model.passenger_id booking.booking_reference = model.booking_reference booking.price = model.price booking.seat_number = model.seat_number booking.flight_class = model.flight_class booking.save() return booking.id
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 create_booking(): data = request.get_json() or {} if 'name' not in data or 'date' not in data or 'phone' not in data: return bad_request('name,date,phone are required') item = Booking() item.from_dict(data) db.session.add(item) db.session.commit() response = jsonify(item.to_dict()) response.status_code = 201 return response
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 render_booking(teacherid, day, time): form = BookingForm(teacher=teacherid, day=day, time=time) if request.method == 'POST': name = form.name.data phone = form.phone.data teacher = form.teacher.data day = form.day.data time = form.time.data db.session.add( Booking(created=datetime.now(), remote_addr=request.remote_addr, name=name, phone=phone, day=day, time=time, teacher_id=teacherid)) db.session.commit() return render_template('booking_done.html', name=name, phone=phone, teacher=teacher, time=time, day=days[day]) return render_template( 'booking.html', teacherid=teacherid, teacher=db.session.query(Teacher).get_or_404(teacherid), daydesc=days[day], day=day, time=time, form=form)
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 index(): contact_form = ContactForm(request.form) if request.method == "POST": if contact_form.validate_on_submit(): name = contact_form.name.data email = contact_form.email.data arrival = contact_form.arrival_date.data departure = contact_form.departure_date.data user = Users(f_name=name, m_name="middle", l_name="last", occupation="work", email_address=email) duration = Booking(arrival_date=arrival, departure_date=departure) db.session.add(user) db.session.add(duration) db.session.commit() email_string = "Hello, " + name + \ " you have made a reservation for " + arrival + " to " + departure send_email(email_string, email) generate_pdf(name) return redirect(url_for('home.index')) return render_template('home/index.html', contact_form=contact_form)
def db_access(first, middle, last, work, email, arrival, departure): """ # Now setup an instance of the tables we are going to interact with in order to store data # instantiate the variables just declared up there with the relevant field in the table that the data will go to # giving it a path :param first: :param middle: :param last: :param work: :param email: :return: """ email_string = "Hello, " + first + middle + last + \ " you have made a reservation for " + arrival + " to " + departure clients = Users(f_name=first, m_name=middle, l_name=last, occupation=work, email_address=email) duration = Booking(arrival_date=arrival, departure_date=departure) Functionality.send_email(email_string, email) # then add these new stored infor to the current user session # commit the changes sessionRep.add(clients) sessionRep.add(duration) sessionRep.commit()
def render_booking_done(): teacher = Teacher.query.filter( Teacher.id == int(request.form.get("clientTeacher"))).first() schedule = Schedule.query.filter( Schedule.id == int(request.form.get("schedule"))).first() form = BookingForm() if form.validate_on_submit(): name = form.clientName.data phone = form.clientPhone.data client = Client(name=name, phone=phone) db.session.add(client) # TODO # изменить ли структуру модели Client # так что бы хранил не id и ссылку # тогда можно без коммита db.session.commit() db.session.add( Booking(client=client.id, teacher=teacher.id, schedule=schedule.id)) db.session.commit() return render_template( "booking_done.html", name=name, phone=phone, day=ReadData.day_week.get(schedule.day_week, ""), time=schedule.time, ) else: return url_for("booking.html")
def book(event_id): data = db.session.query(Event).join( Location, Location.id == Event.location_id).with_entities( Event.name, Event.capacity, Event.start, Event.end, Location.name.label('location_name'), Location.address, Event.img_name).filter(Event.id == event_id).first() ticket_amt = [(i, i) for i in range(1, data.capacity + 1)] form = BookingForm() form.amount.choices = ticket_amt if data is None: return render_template('error_event.html') if form.validate_on_submit(): event = Event.query.get(event_id) event.capacity -= form.amount.data booking = Booking(user_id=current_user.id, event_id=event_id, quantity=form.amount.data, book_time=datetime.utcnow(), last_modified=datetime.utcnow()) db.session.add(booking) db.session.commit() app.logger.info( 'User ID {} has booked {} tickets (Booking ID {}) for Event ID {} at {}.' .format(booking.user_id, booking.quantity, booking.id, booking.event_id, datetime.now())) flash( 'Successfully purchased {} tickets for {}'.format( form.amount.data, data.name), "info") return redirect(url_for('main_panel.events')) return render_template('book.html', event_id=event_id, data=data, form=form)
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 create_booking(bus_id): bus = Bus.query.get(bus_id) if not bus.booking_time_expired(): create_booking_form = CreateBookingForm(data=request.form, bus=bus) if create_booking_form.validate_on_submit(): # create booking grid_id = create_booking_form.grid_id.data pricing_id = create_booking_form.pricing_id.data passenger_name = create_booking_form.passenger_name.data passenger_telephone = create_booking_form.passenger_telephone.data pickup = create_booking_form.pickup.data pricing = Pricing.query.get(pricing_id) grid = Grid.query.get(grid_id) branch = bus.branch user = current_user if not user.is_authenticated: user = None fare = pricing.price stop = pricing.stop booking = Booking(passenger_name=passenger_name, passenger_telephone=passenger_telephone, seat_number=grid.number, pickup=pickup, fare=fare, stop=stop, grid_id=grid_id, pricing_id=pricing_id, paid=True, branch=branch, bus=bus, created_by=user.id) db.session.add(booking) grid.booking = booking create_payment(booking) db.session.commit() bookings = bus.bookings booking_fields = Fields().booking_fields() bookings_json = json.loads( json.dumps(marshal_data(bookings, booking_fields))) res = json.dumps({ "handle": "create_booking_passed", "data": { "grid": grid.grid_dict(), "bookings": bookings_json } }) redis.publish(app.config.get("REDIS_CHAN"), res) flash(f'Booked Seat {grid.number}', 'success') return redirect(url_for('bus.get_bus', bus_id=bus.id)) else: flash(f'Failed', 'danger') return render_template("bus/bus.html", bus=bus, create_booking_form=create_booking_form)
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 property(request, property_id): prop = Property.objects.get(id=property_id) bookings = Booking.objects.filter(property=property_id) checker = None guest = None if request.method == 'POST': guest = request.POST.get('guest') start_date = request.POST.get('start_date') start_date = datetime.strptime(start_date, '%Y-%m-%d').date() end_date = request.POST.get('end_date') end_date = datetime.strptime(end_date, '%Y-%m-%d').date() price = prop.price * (end_date - start_date).days * 1.08 if len(bookings) > 0: for booking in bookings: if (booking.start_date <= start_date <= booking.end_date or booking.start_date <= end_date <= booking.end_date ) or (start_date <= booking.start_date and end_date >= booking.end_date): checker = False else: checker = True else: checker = True if checker: p = Booking(property=prop, start_date=start_date, end_date=end_date, price=price, guest=guest) p.save() context = { 'property': prop, 'checker': checker, 'guest': guest, } return render(request, 'app/property.html', context)
def saveBooking(request): name = request.POST.get('u_name') block_name = request.POST.get('bn') flat_type = request.POST.get('ft') flat_no = request.POST.get('fno') email = request.POST.get('u_email') purpose = request.POST.get('u_pur') date = request.POST.get('u_date') message = request.POST.get('u_mes') # print(name,block_name,flat_type,flat_no,email,purpose,date,message) bk = Booking(name=name, flat_no=flat_no, booking_purpose=purpose, booking_date=date, message=message, email=email, flat_type=flat_type, block_name=block_name) bk.save() res = UserRegister.objects.get(flat_no=flat_no) return render(request, 'userhome.html', {'res': res})
def booking(teacher_id, day, hour): form = BookingForm() if form.validate_on_submit(): bk = Booking(teacher_id=teacher_id, day=day, hour=hour) bk.student_name = form.contact_info.student_name.data bk.student_phone = form.contact_info.student_phone.data teacher = Teacher.query.get(teacher_id) teacher.set_hour_state(day, hour, False) # теперь время - занято bk.save() return render_template("done.html", title={ "label": "Тема", "value": "Пробный урок" }, time={ "label": days[bk.day], "value": f"{bk.hour}:00" }, name=bk.student_name, phone=bk.student_phone) return render_template("booking.html", teacher=Teacher.query.get(teacher_id), time={ "day": day, "hour": hour }, days=days, form=form)
def create_booking(): form = BookingForm() form['csrf_token'].data = request.cookies['csrf_token'] print() if form.validate_on_submit(): booking = Booking(book_date=form.data['book_date'], book_start_time=form.data['book_start_time'], book_end_time=form.data['book_end_time'], user_id=form.data['user_id'], service_id=form.data['service_id']) db.session.add(booking) db.session.commit() newbooking = Booking.query.filter_by(id=booking.id).join(Aircraft).one() return to_booking(newbooking)
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 CreateBooking(request): print("Request is : ", request.json) if not request.json: return jsonify({'message': 'No input data provided '}), 400 content = request.get_json() schema = BookingSchema() bookingData = schema.load(content) newAsset = bookingData.data a = Booking(**newAsset) db.session.add(a) try: db.session.commit() return jsonify({"sucess": True}) except IntegrityError: return jsonify({"sucess": False}) db.session.rollback()
def booking(teacher_id): teacher = db.session.query(Teacher).get_or_404(teacher_id) form = BookingForm() if form.validate_on_submit(): weekday_ru = request.args.get('day') time = request.args.get('time') weekday_slug = next( (day_en for day_en, day_ru in RU_DAYS.items() if weekday_ru == day_ru), None ) booking = Booking( username=form.name.data, phone=form.phone.data, weekday=weekday_ru, time=time ) teacher_schedule = json.loads(teacher.schedule) teacher_schedule[weekday_slug][time] = False teacher.schedule = json.dumps(teacher_schedule) teacher.bookings.append(booking) db.session.add(teacher) db.session.add(booking) db.session.commit() context = { 'name': booking.username, 'phone': booking.phone, 'lesson_day': booking.weekday , 'lesson_time': booking.time, 'subject': 'trial', 'subject_description': 'Пробное занятие' } return redirect(url_for('sent', context=json.dumps(context))) context = { 'teacher': teacher, 'lesson_day': RU_DAYS[request.args.get('day')], 'lesson_time': request.args.get('time') } return render_template('booking.html', form=form, **context)
def create_booking(): if not request.json or not 'book_id' in request.json or not 'user_id' in request.json or not 'start_date' in request.json or not 'end_date' in request.json: abort(400) u = User.query.get(int(request.json['user_id'])) b_id = request.json['book_id'] if not u or not b_id: abort(500) book_id_api = requests.get("http://63.34.166.57:8080/book/id/{0}".format(b_id)) if book_id_api.status_code != 200: abort(500) book_id = book_id_api.json() check = Booking.query.filter(and_(Booking.book_id == book_id["id"], Booking.start_date <= request.json["end_date"], request.json["start_date"] <= Booking.end_date)).all() print(check, file=sys.stderr) if check: return jsonify({'message': 'Booking overlap.'}), 200 b = Booking(book_id=book_id["id"], booker=u, start_date=request.json["start_date"], end_date=request.json["end_date"]) db.session.add(b) db.session.commit() return jsonify({'message': 'Booking completed.'}), 201
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 create_booking(**kwargs): required_params = ['slot_id', 'consultation_with', 'additional_note', 'reason'] if 'DC=techlab' not in kwargs['cas:distinguishedName']: abort(401, "Unauthorized to access this resource") if not request.json: abort(400, "Request should be in JSON format") if not all(param in request.json for param in required_params): abort(400, "One or more required fields not found") # validate if any of the request param is empty for key in required_params: if request.json[key] is None or request.json[key] == "": abort(400, "One or more required param is empty") # validate if the provided slot id is not booked if Booking.query.filter_by(slot_id=request.json['slot_id']).first(): abort(409, "Slot is already booked") slot = Slot.query.filter_by(id=request.json['slot_id'], status='Available'). \ first_or_404(description='invalid slot_id supplied') bookings = Booking.query.filter_by(student_sam_account_name=kwargs['cas:sAMAccountName']).all() # for booking in bookings: # if slot.datetime == Slot.query.filter_by(id=booking.slot_id).first().datetime: # abort(409, "Student can not book two slots at same time") # # if (slot.datetime - datetime.now()).seconds <= 1: # abort(409, "slot booking time already passed") new_booking = Booking.deserialize(request.json) new_booking.student_sam_account_name = kwargs['cas:sAMAccountName'] new_booking.status = "Booked" new_booking.booking_datetime = datetime.now() slot.status = "Booked" slot.booking_slots.append(new_booking) db.session.add(new_booking) db.session.commit() return jsonify({"message": "Booking has been added successfully"}), 201
def test_json(data): data = json.loads(data) try: b = Booking(id=data['id'], user_id=data['user_id'], vehicle_model_id=data['vehicle_model_id'], package_id=data['package_id'], travel_type_id=data['travel_type_id'], from_area_id=data['from_area_id'], to_area_id=data['to_area_id'], from_city_id=data['from_city_id'], to_city_id=data['to_city_id'], from_date=data['from_date'], to_date=data['to_date'], online_booking=data['online_booking'], mobile_site_booking=data['mobile_site_booking'], booking_created=data['booking_created'], from_lat=data['from_lat'], from_long=data['from_long'], to_lat=data['to_lat'], to_long=data['to_long'], Car_Cancellation=data['Car_Cancellation']) db.session.add(b) db.session.commit() # log succesful addition emit('my_response', {'success': True, 'id': data['id']}) except KeyError: # log data with exception emit('my_response', { 'success': False, 'id': data['id'], 'cause': 'Unrecognised attribute' }) except: # log data emit('my_response', { 'success': False, 'id': data['id'], 'cause': 'Unknows error' })