def book_room(request, pk):
if request.method == 'POST':
booking_form = BookingForm(data=request.POST)
room = Room.objects.get(pk=pk, available=True)
print(request.POST.get('check_in_date'))
# print(booking_form.check_out_date)
print(booking_form.is_valid())
if booking_form.is_valid():
print("valid")
booking = booking_form.save(commit=False)
booking.room = room
booking.customer = request.user.customer
booking.save()
return render(request, 'cart.html', {'booking': booking})
else:
print(booking_form.errors)
else:
booking_form = BookingForm()
return render(request, 'book.html', {
'booking_form': booking_form,
'pk': pk
})
def addQueue(request):
try:
userprofile = UserProfile.objects.get(pk=request.user)
except UserProfile.DoesNotExist:
return render(request, "booking/booking_status_empty_profile.html")
try:
if request.method == 'POST': # If the form has been submitted...
form = BookingForm(request.POST) # A form bound to the POST data
if form.is_valid():
maxPeople_preference = form.cleaned_data['maxPeople_preference']
backend.addQueue(request.user, userprofile.serie, maxPeople_preference)
backend.refreshBooking(userprofile.serie)
return redirect("booking.views.status")
else:
render(request, 'booking/booking_start.html', {
'form': form,
}
)
else:
return redirect("booking.views.status")
except:
return render(request, 'booking/booking_start.html', {
'form': BookingForm(),
}
)
def booking(request):
#THIS IS COSTYL
cart_list = Cart.objects.all()
CART_ID='CART-ID'
cart_id=request.session[CART_ID]
print(request.session[CART_ID])
user_cart = Cart.objects.get(id=cart_id)
item_list = Item.objects.filter(cart = user_cart)
mailing_list = Mail.objects.all()
if request.method == 'POST':
form = BookingForm(request.POST, request.FILES)
if form.is_valid():
# file is saved
#form.save()
total_price = 0
for item in item_list:
total_price += item.product.price
user_name = form.cleaned_data['user_name']
user_sec_name = form.cleaned_data['user_sec_name']
user_mail = form.cleaned_data['user_mail']
user_phone =form.cleaned_data['user_phone']
num = random.randint(1, 10000)
booking_item = Booking(name = "Заказ id" + " " + str(num), user_name = user_name, user_sec_name=user_sec_name, user_mail=user_mail, user_phone = user_phone, total_sum=total_price)
booking_item.save()
message = email_message(user_name, user_sec_name, user_mail, user_phone, total_price)
print(item_list)
for item in item_list:
booking_item.items.add(item)
return HttpResponseRedirect("/thanx/")
else:
form = BookingForm()
data = {'form': form}
return render(request, 'bookings.html', data)
def addQueue(request):
try:
userprofile = UserProfile.objects.get(pk=request.user)
except UserProfile.DoesNotExist:
return render(request, "booking/booking_status_empty_profile.html")
try:
if request.method == 'POST': # If the form has been submitted...
form = BookingForm(request.POST) # A form bound to the POST data
if form.is_valid():
maxPeople_preference = form.cleaned_data[
'maxPeople_preference']
backend.addQueue(request.user, userprofile.serie,
maxPeople_preference)
backend.refreshBooking(userprofile.serie)
return redirect("booking.views.status")
else:
render(request, 'booking/booking_start.html', {
'form': form,
})
else:
return redirect("booking.views.status")
except:
return render(request, 'booking/booking_start.html', {
'form': BookingForm(),
})
def booking(request, resident_id):
resident = get_object_or_404(booking_models.Resident, pk=resident_id)
estate = resident.estate
form = BookingForm(request.GET)
#import pdb;pdb.set_trace()
if form.is_valid():
obj = form.save(commit=False)
code = randrange(10002321, 99221025)
obj.code = code
obj.resident = resident
obj.save()
msg = "You have been booked by {resident.name} into\
{resident.estate.name} with code: {code}".format(
resident=resident, code=code)
phone = '234{}'.format(obj.phone[-10:])
#payload = {
# 'sender': 'V LOGIN',
# 'to': '234{}'.format(obj.phone[-10:]),
# 'msg': msg
#}
send_message(phone, msg)
#sms_url = 'http://shoutinsms.bayo.webfactional.com/api/sendmsg/'
#requests.get(sms_url, params=payload)
booking_models.SentMessage.objects.create(resident=resident)
estate.balance -= 1
estate.save()
return HttpResponse('A message has been sent to your visitor.')
return HttpResponseBadRequest('An error occured. Please try again')
def book(request, bookable):
if not request.user.is_authenticated:
return render(request, 'modals/forbidden.html')
booking = Booking()
bookable_obj = get_object_or_404(Bookable, id_str=bookable)
context = {
'url': request.path,
'bookable': bookable_obj,
'user': request.user,
}
if request.method == 'GET':
booking.start = dateutil.parser.parse(request.GET['st']) if 'st' in request.GET else datetime.now()
booking.end = dateutil.parser.parse(request.GET['et']) if 'et' in request.GET else start + timedelta(hours=1)
booking.bookable = bookable_obj
booking.user = request.user
form = BookingForm(instance=booking)
status = 200
elif request.method == 'POST':
form = BookingForm(request.POST, instance=booking)
if form.is_valid():
form.save()
return HttpResponse()
else:
status = 400
else:
raise Http404
context['form'] = form
return render(request, 'book.html', context=context, status=status)
def post(self, request, slug, pk):
hotel = get_object_or_404(Hotel, slug=slug)
room = get_object_or_404(Room, pk=pk)
booking_form = BookingForm(request.POST, applicant=self.request.user)
if check_time_is_valid(room, booking_form['check_in_time'].data,
booking_form['days'].data):
if booking_form.is_valid():
new_booking = Booking.objects.create(
unit_of_applicant=booking_form['unit_of_applicant'].data,
applicant=request.user,
use=booking_form['use'].data,
check_in_time=datetime.strptime(
(booking_form['check_in_time'].data + " 15:00"),
'%Y-%m-%d %H:%M'),
check_out_time=datetime.strptime(
(booking_form['check_in_time'].data + " 12:00"),
'%Y-%m-%d %H:%M') +
timedelta(days=int(booking_form['days'].data)),
booked_room=room)
# To record the origin information about this booking, or if the hotel owner been changed then it will
# not found who is owner at that time.
UseList = [_ for _ in Use.__members__.values()]
origin_info_txt = "Unit of applicant:\t" + new_booking.unit_of_applicant + "\n" + \
"Applicant:\t" + new_booking.applicant.get_full_name() + "\n" + \
"Use:\t" + str(UseList[int(new_booking.use)-1].value[2]) + "\n" + \
"Check in time:\t" + datetime.strftime(new_booking.check_in_time, '%Y-%m-%d %H:%M') + "\n" + \
"Check out time:\t" + datetime.strftime(new_booking.check_out_time, '%Y-%m-%d %H:%M') + "\n" + \
"Room:\t" + new_booking.booked_room.__str__() + "\n" + \
"Price:\t" + str(new_booking.total_price) + "\n" + \
"Owner:\t" + new_booking.booked_room.hotel.owner.get_full_name() + "\n" + \
"Create time:\t" + datetime.strftime(new_booking.created_time, '%Y-%m-%d %H:%M')
new_booking.origin_info_txt = origin_info_txt
new_booking.save()
messages.success(request, "Booked Successfully.")
# booking_notification_mail(hotel.owner, new_booking)
return redirect('guest_edit', pk=new_booking.pk)
else:
messages.warning(request, "Time Conflict.")
template = 'booking.html'
context = {
'hotel':
hotel,
'room':
room,
'uses':
Use.__members__.values(),
'booking_form':
BookingForm(request.POST, applicant=self.request.user)
}
return render(request, template, context)
def test_invalid_data(self):
data = {
'user': self.user.id,
'name_on_teller': 'Ade Oluwa',
'date_of_payment': '02-03-1956',
'bank_name': 'GTBank'
}
form = BookingForm(data)
self.assertFalse(form.is_valid())
self.assertEqual(form['date_of_payment'].errors, [u'Enter a valid date.'])
def test_success(self):
data = {
'user': self.user.id,
'name_on_teller': 'Ade Oluwa',
'date_of_payment': '02/03/1956',
'bank_name': 'GTBank'
}
form = BookingForm(data)
self.assertTrue(form.is_valid())
b = form.save()
self.assertEqual(repr(b), '<Booking: Ade Oluwa>')
def test_valid_manypeople(self):
form = BookingForm(
data={
'date': datetime.date(2020, 5, 8),
'start_time': '16:00',
'duration': 6,
'student': 'no',
'number_people': 500,
'refrigerator': 'yes',
'occasion': 'party'
})
self.assertTrue(form.is_valid(), form.errors)
def test_invalid_zeropeople(self):
form = BookingForm(
data={
'date': datetime.date(2020, 5, 9),
'start_time': '11:00',
'duration': 12,
'student': 'no',
'number_people': 0,
'refrigerator': 'yes',
'occasion': 'party'
})
self.assertFalse(form.is_valid(), form.errors)
def test_invalid_start(self):
form = BookingForm(
data={
'date': datetime.date(2020, 5, 9),
'start_time': datetime.time(hour=0, minute=1),
'duration': 12,
'student': 'yes',
'number_people': 5,
'refrigerator': 'yes',
'occasion': 'party'
})
self.assertFalse(form.is_valid(), form.errors)
def get_details(request, listing_id):
user = request.user
search_query = request.session.get('search_query')
json_query = json.loads(search_query)
available_dates_with_price = DBManager.get_available_dates_with_price(
listing_id)
listing = DBManager.get_listing_for_id(listing_id)
best_time = DBManager.get_best_time_to_visit(listing_id)
check_in_string = json_query.get('from_date')
check_out_string = json_query.get('to_date')
dict_dates = {
'check_in': check_in_string,
'check_out': check_out_string,
'available_dates_with_price': available_dates_with_price
}
if request.method == "POST":
booking_form = BookingForm(data=request.POST)
if booking_form.is_valid():
booking = booking_form.cleaned_data
success = DBManager.add_booking(booking)
if success == True:
return render(request, 'listing/confirmation.html',
{'listing': listing})
else:
booking_form.errors['DB Error '] = success
return render(
request, 'listing/details/details.html', {
'listing': listing,
'booking_form': booking_form,
'dict_dates': dict_dates,
'best_time': best_time
})
else:
booking = Booking()
booking.customer_id = user.user_id
booking.listing_id = listing_id
booking.number_of_guests = json_query.get('num_guests')
booking.price = 0
booking_form = BookingForm(instance=booking)
return render(
request, 'listing/details/details.html', {
'listing': listing,
'booking_form': booking_form,
'dict_dates': dict_dates,
'best_time': best_time
})
def addBooking(request):
if request.method == 'POST':
form = BookingForm(request.user, request.POST)
if form.is_valid():
booking = form.save(commit=False)
Booking.objects.clearCache(booking.date.year, booking.date.month)
if request.user.is_authenticated():
booking.user = request.user
booking.save()
return redirect('/booking') #redirect on success
else:
form = BookingForm(request.user)
return render_to_response('booking/addBooking.html', {'form': form}, context_instance=RequestContext(request))
def gallery_list_view(request):
gallery_object_list = Gallery.objects.all()
if request.method == 'POST':
contact_form = ContactForm(request.POST)
booking_form = BookingForm(request.POST)
if contact_form.is_valid():
contact_form.save()
name = contact_form.cleaned_data.get('name')
email = contact_form.cleaned_data.get('email')
phone_number = contact_form.cleaned_data.get('phone_number')
message = contact_form.cleaned_data.get('message')
messages.success(
request,
f'{name}, your details has been sent!, We will get to you as soon as possible. Thank You!'
)
send_mail(
'Contact Request',
f' {name} has requested to contact you. Contact Info:{phone_number}, {email}. He has left a message : {message}',
'*****@*****.**', ['*****@*****.**'],
fail_silently=True)
return redirect('gallery_list')
if booking_form.is_valid():
booking_form.save()
name = booking_form.cleaned_data.get('name')
room = booking_form.cleaned_data.get('room')
check_in = booking_form.cleaned_data.get('check_in')
check_out = booking_form.cleaned_data.get('check_out')
adult = booking_form.cleaned_data.get('adult')
child = booking_form.cleaned_data.get('child')
messages.success(
request,
f' {name}, Your Booking has been successful for {room}, from {check_in} to {check_out} with {adult} adults and {child} childrens.Thank You!!!'
)
send_mail(
f'Booking BY {name} ',
f'A booking has been made for {room} , from {check_in} to {check_out} with {adult} adults and {child} childrens.',
'*****@*****.**', ['*****@*****.**'],
fail_silently=True)
return redirect('gallery_list')
else:
contact_form = ContactForm()
booking_form = BookingForm()
context = {
'booking_form': booking_form,
'contact_form': contact_form,
'gallery_object_list': gallery_object_list
}
return render(request, 'gallery/gallery_list.html', context)
def edit_booking(request, booking_id=None):
"""
View for adding a new booking to the database.
:param booking_id:
:param request:
:return:
"""
if booking_id:
booking = get_object_or_404(Booking, pk=booking_id)
else:
booking = Booking(requester=request.user)
form = BookingForm(request.POST or None, instance=booking)
if request.POST and form.is_valid():
# check the permissions
if not request.user.has_perm("booking.change_booking", booking):
raise PermissionDenied("User may not edit booking")
booking = form.save()
form_html = render_crispy_form(
BookingForm(instance=booking),
context=csrf(request),
)
booking_html = render_to_string(
"booking/partials/booking-item.html",
{
"booking": booking,
"form": BookingForm(instance=booking),
"include_game": bool(request.GET.get("include_game", False)),
"include_group": bool(request.GET.get("include_group", False)),
},
request=request,
)
return JsonResponse({
"success": True,
"form_html": form_html,
"booking_html": booking_html,
})
form_html = render_crispy_form(form, context=csrf(request))
return JsonResponse({"success": False, "form_html": form_html})
def event(request, event_datum, event_time, event_dur):
"""
Render event.html with BookingForm.
If form is submitted redirect to a confirmation page
"""
form = BookingForm(request.POST or None)
yearstr = datetime.strptime(event_datum, '%Y-%m-%d')
form.fields['date'].initial = yearstr.strftime('%Y-%m-%d')
form.fields['start_time'].initial = event_time
form.fields['duration'].initial = event_dur
if request.POST and form.is_valid():
instance = form.save(commit=False)
instance.author = request.user
instance.save()
return HttpResponseRedirect(reverse('booking:confirm'))
return render(request, 'booking/event.html', {'form': form})
def booking(request):
"""Booking form processing"""
# If an ID is provided then an existing booking is edited, otherwise a new one is created
if request.POST.get("id", "") != "":
book = get_object_or_404(Booking, id=int(request.POST["id"]))
if book.user == request.user:
form = BookingForm(request.POST, instance=book)
else:
return HttpResponse(status=403)
else:
form = BookingForm(request.POST)
if form.is_valid():
# User is set to connected user
book = form.save(commit=False)
book.user = request.user
book.save()
# Return a new component for the created or edited booking
context = {"booking": book}
template = loader.get_template("booking/booking.html")
# 'success' is to tell frontend that a booking component is returned
return JsonResponse({
"success": True,
"html": template.render(context, request)
})
# If form is invalid, return the form sub-template including errors
context = {"booking_form": form}
template = loader.get_template("booking/booking_form.html")
# 'success' tells frontend that a form component is returned
return JsonResponse({
"success": False,
"html": template.render(context, request)
})
def new_booking(request):
start_semester = Settings.objects.last().start_semester
end_semester = Settings.objects.last().end_semester
user = request.user
if request.method == "POST":
form_booking = BookingForm(request.user, request.POST)
if (form_booking.is_valid()):
booking = form_booking.save(request.user)
if booking:
request.session['booking'] = booking.pk
return render(request, 'booking/showDates.html',
{'booking': booking})
else:
messages.error(request, _("Booking alread exists"))
else:
form_booking = BookingForm(request.user)
return render(
request, 'booking/newBooking.html', {
'form_booking': form_booking,
'start_semester': start_semester,
'end_semester': end_semester,
'is_staff': user.is_staff
})
def FutsalDetailView(request, slug):
futsal = get_object_or_404(Futsal, slug=slug)
user = request.user
# Booking form
if request.method == "POST":
form = BookingForm(request.POST or None)
if form.is_valid():
instance = form.save(commit=False)
instance.user = user
instance.futsal = futsal
pre_booked = Booking.objects.filter(futsal=instance.futsal,
date=instance.date,
time=instance.time).exists()
# check if futsal is pre booked
if pre_booked:
messages.error(request, 'Already booked by others.')
instance = form.save(commit=False)
return HttpResponseRedirect(futsal.get_absolute_url())
instance.save()
messages.success(request, 'Futsal Game Booked Successfully.')
return HttpResponseRedirect(futsal.get_absolute_url())
else:
print('error')
form = BookingForm()
# check if saved:
is_saved = False
if user.profile.favourites.filter(id=futsal.id).exists():
is_saved = True
else:
is_saved = False
# show bookings of the futsal for today
bookings = Booking.objects.filter(
futsal=futsal,
date=datetime.date.today(),
)
context = {
'form': form,
'bookings': bookings,
'futsal': futsal,
'today': datetime.date.today(),
'is_saved': is_saved,
'lat': futsal.lat,
'lng': futsal.lng,
}
return render(request, 'futsalApp/detail.html', context)
# def comment(request):
# context = {}
# if request.method == "POST":
# form = ReviewForm(request.POST or None)
# if form.is_valid():
# instance = form.save(commit=False)
# instance.futsal = request.POST.get('futsal_id')
# print(instance.futsal)
# instance.user = request.user
# instance.save()
# context['comment'] = instance.review
# context['user'] = request.user.username
# context['date'] = instance.date
# context['futsal'] = instance.futsal
# return JsonResponse({'data':context})
# else:
# form = ReviewForm()
# return JsonResponse({'error':'Error occoured.'})
# class FutsalDetailView(LoginRequiredMixin, FormMixin, generic.DetailView):
# model = Futsal
# template_name = 'futsalApp/detail.html'
# context_object_name = 'futsal'
# slug_url_kwarg = 'slug'
# form_class = BookingForm
# def get_object(self, queryset=None):
# obj = super().get_object(queryset=queryset)
# return obj
# def check_if_saved(self):
# user = self.request.user
# is_saved = False
# if user.profile.favourites.filter(id=self.get_object().id).exists():
# is_saved = True
# return is_saved
# def get_success_url(self):
# return HttpResponseRedirect(reverse('futsal-detail', kwargs={'slug':self.get_object().slug}))
# def get_context_data(self, **kwargs):
# context = super(FutsalDetailView, self).get_context_data(**kwargs)
# context['form'] = BookingForm(initial={'post':self.get_object()})
# context['bookings'] = Booking.objects.filter(
# futsal=self.get_object(),
# date=datetime.date.today(),
# )
# context['today'] = datetime.date.today()
# context['is_saved'] = self.check_if_saved()
# context['review_form'] = ReviewForm()
# # for frontend values
# context['lat'] = self.get_object().lat
# context['lng'] = self.get_object().lng
# return context
# def post(self, request, *args, **kwargs):
# form = self.get_form()
# if form.is_valid():
# instance = form.save(commit=False)
# instance.user = self.request.user
# instance.futsal = self.get_object()
# while Booking.objects.filter(futsal=instance.futsal,date=instance.date,time=instance.time).exists():
# messages.error(self.request,'Already booked')
# instance.save(commit=False)
# return HttpResponseRedirect(self.get_object().get_absolute_url())
# instance.save()
# messages.success(self.request, 'Futsal Game Booked Successfully.')
# return self.get_success_url()
# else:
# messages.error(self.request, 'Booking Failed')
# return HttpResponseRedirect(self.get_object().get_absolute_url())
def test_form_is_valid(self):
form = BookingForm(data=self.parameters)
self.assertTrue(form.is_valid())
def test_valid_timeslot(self):
form = BookingForm(data=self.form_data)
self.assertTrue(form.is_valid())
def test_invalid_timeslot(self):
Booking.objects.create(**self.form_data)
form = BookingForm(data=self.form_data)
self.assertFalse(form.is_valid())
self.assertTrue(form.has_error('time_slot'))
def review_a_booking(request, asset_id):
bookingform = BookingForm()
user_ok = False
the_asset = get_object_or_404(Asset, id=asset_id)
#check user is linked to the asset provided
if check_user_linked_to_asset(request.user, asset_id):
#is the requestor activated?
if check_user_activated(request.user, asset_id):
user_ok = True
else:
user_ok = False
messages.add_message(request, messages.ERROR,
"Account Deactivated")
else:
user_ok = False
messages.add_message(request, messages.ERROR,
"You are not authorised to view this page")
if user_ok:
#sessions variables must exist
#variables from the session
if 'selected_day_cal' in request.session:
day = (request.session['selected_day_cal'])
if 'selected_month_cal' in request.session:
month = (request.session['selected_month_cal'])
if 'selected_year_cal' in request.session:
year = (request.session['selected_year_cal'])
if 'selected_hour_cal' in request.session:
hour = (request.session['selected_hour_cal'])
if 'selected_minute_cal' in request.session:
minute = (request.session['selected_minute_cal'])
try:
the_values = "%s - %s - %s - %s - %s" % (year, month, day, hour,
minute)
url_date = datetime.datetime(int(year), int(month), int(day),
int(hour), int(minute))
except:
clear_date_and_time_from_session
code_message = "There was a problem with the date, please re-select from the booking calendar " + the_values
messages.add_message(request, messages.ERROR, code_message)
return redirect(
reverse_lazy('make_a_booking',
kwargs={"asset_id": the_asset.id}))
else:
show_date_format = url_date.strftime("%A, %d %B")
show_time_format = url_date.strftime("%H:%M")
if request.method == "POST":
form = BookingForm(request.POST)
if form.is_valid():
cd = form.cleaned_data
hour = int(cd['hour'])
minute = int(cd['minute'])
day = int(cd['day'])
month = int(cd['month'])
year = int(cd['year'])
url_date = datetime.datetime(year, month, day, hour,
minute)
the_request_date = datetime.datetime(year, month, day)
the_request_time = datetime.time(hour, minute)
#check things about the date first here before saving
#the date has already been checked before being saved to the session
#check if the time-slot is still available (could be a delay with confirming the booking)
new_booking = Booking(
requested_by_user_ID=request.user,
asset_ID=the_asset,
requested_date=the_request_date,
requested_start_time=the_request_time)
try:
new_booking.save()
new_id = new_booking.pk
#redirect to bookings page
clear_date_and_time_from_session
#send email to user
user_email = request.user.email
current_site = get_current_site(request)
domain = current_site.domain
delete_link = "%s/%s/%s/" % (domain, "booking/delete",
new_id)
message_body = "Here are the details of your recent booking: " + show_date_format + " at " + show_time_format
message_body += " To delete this booking at any time, click <a href='" + delete_link + "'>here</a>"
con = get_connection()
send_mail("Count Me In = booking",
message_body,
"*****@*****.**",
['*****@*****.**', user_email],
connection=con)
return redirect(
reverse_lazy('my_bookings',
kwargs={
"asset_id": the_asset.id,
"booking_id": new_id
}))
except IntegrityError as code_message:
code_message = "You have already booked that particular time slot, please choose another"
messages.add_message(request, messages.ERROR,
code_message)
clear_date_and_time_from_session
#redirect to bookings page
return redirect(
reverse_lazy('make_a_booking',
kwargs={"asset_id": the_asset.id}))
else:
print(form.errors)
#form not valid
else:
bookingform = BookingForm(
initial={
'requested_date': show_date_format,
'requested_start_time': show_time_format,
'hour': hour,
'minute': minute,
'day': day,
'year': year,
'month': month
})
return render(
request, "booking/confirm_booking.html", {
"asset": the_asset,
'bookingform': bookingform,
'request_date': show_date_format,
'request_time': show_time_format,
"user_ok": user_ok
})
