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 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 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_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 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 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 booking(request):
form = BookingForm()
wrong_date_selection = False
clash = False
request_made = False
if request.POST:
form = BookingForm(request.POST)
utc = pytz.UTC
room_no = request.POST['Room_no']
booking_start = utc.localize(
dateutil.parser.parse(request.POST['Booking_start']))
booking_end = utc.localize(
dateutil.parser.parse(request.POST['Booking_end']))
print(room_no, booking_start, booking_end)
if (booking_start > booking_end) or (booking_start < utc.localize(
datetime.now()) or booking_end < utc.localize(datetime.now())):
wrong_date_selection = True
print("Wrong Date Selected.")
return render(
request, 'booking.html', {
'verified': request.user.profile.email_confirmed,
'wrong_date_selection': wrong_date_selection,
'form': form
})
else:
booking = Booking(Room_no=Room.objects.get(pk=room_no),
Booking_start=booking_start,
Booking_end=booking_end,
user=request.user.profile)
booking.save()
request_made = True
return render(
request, 'booking.html', {
'verified': request.user.profile.email_confirmed,
'booking': booking,
'form': form,
'request_made': request_made
})
else:
print("Inside Booking")
return render(
request, 'booking.html', {
'verified': request.user.profile.email_confirmed,
'form': form,
'clash': clash,
'wrong_date_selection': wrong_date_selection
})
def login_user(request):
login_failed = False
logout(request)
username = password = ''
if request.POST:
username = request.POST['username']
password = request.POST['password']
user = authenticate(username=username, password=password)
if user is not None:
login_failed = False
form = BookingForm()
if user.is_active:
login(request, user)
print("User is Not none and active as well.")
else:
login(request, user)
print("User is Not None but not Active.")
return HttpResponseRedirect(
'/booking/', {
'verified': request.user.profile.email_confirmed,
'login_failed': login_failed,
'form': form
})
else:
login_failed = True
print("User is None")
return render(request, 'home.html', {'login_failed': login_failed})
def form_with_group(self):
from booking.forms import BookingForm
form = BookingForm(instance=self,
auto_id="id_booking_%s_" + str(self.id))
form.helper.form_action += "?include_game=True&include_group=True"
return form
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 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 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 status(request):
try:
userprofile = UserProfile.objects.get(pk=request.user)
except UserProfile.DoesNotExist:
return render(request, "booking/booking_status_empty_profile.html")
try:
queue = Queue.objects.get(user=request.user)
count = Queue.objects.filter(dateAdded__lt=queue.dateAdded).count()
return render(request, "booking/booking_status_queue_position.html",
{"position": count})
except Queue.DoesNotExist:
try:
slotBooked = SlotBooked.objects.get(user=request.user)
roomBooked = Room.objects.get(slot__slotbooked__pk=slotBooked.id)
if slotBooked.isPaid():
return render(
request, "booking/booking_status_room_booked_paid.html", {
"number": roomBooked.number,
"type": roomBooked.get_type_display,
"paymentDate": slotBooked.datePaid,
})
else:
paypal_dict = {
"business": settings.PAYPAL_RECEIVER_EMAIL,
"amount": settings.PAYPAL_AMOUNT,
"currency_code": "EUR",
"item_name": u"Réservation chambre ENPC",
"invoice": slotBooked.id,
"notify_url": settings.PAYPAL_NOTIFY_URL,
"return_url": request.build_absolute_uri(),
"cancel_return": request.build_absolute_uri(),
}
return render(
request,
"booking/booking_status_room_booked_not_paid.html", {
"number": roomBooked.number,
"type": roomBooked.get_type_display,
"paymentDue": slotBooked.dateLimit,
"form": PayPalPaymentsForm(initial=paypal_dict),
})
except SlotBooked.DoesNotExist:
return render(request, 'booking/booking_start.html', {
'form': BookingForm(),
})
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 createbooking(request):
if request.POST:
form = BookingForm(request.POST)
if form.is_valid:
form.save()
else:
form = BookingForm()
args = {}
args['form'] = form
return render_to_response('booking/booking.html', args)
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 get(self, request, slug, pk):
try:
hotel = get_object_or_404(Hotel, slug=slug)
room = get_object_or_404(Room, pk=pk)
template = 'booking.html'
context = {
'hotel': hotel,
'room': room,
'uses': Use.__members__.values(),
'booking_form': BookingForm(applicant=self.request.user)
}
return render(request, template, context)
except:
messages.warning(request,
"Please update your officer information first.")
return redirect('officer_index')
def index(request):
"""Home page listing resources and user's bookings"""
# Admin can see all, users can see theirs only
if request.user.has_perm("admin"):
bookings = Booking.objects.all()
else:
bookings = Booking.objects.filter(user=request.user)
context = {
"resources": Resource.objects.all(),
"bookings": bookings,
"resource_form": ResourceForm(),
"booking_form": BookingForm(),
"profile_form": ProfileForm(instance=request.user.profile),
"now": timezone.now(),
}
return render(request, "booking/index.html", context)
def _get_game_response(game, request):
form_html = render_crispy_form(
GameForm(instance=game, auto_id="id_%s_" + uuid.uuid4().hex),
context=csrf(request),
)
game_html = render_to_string(
"booking/partials/game-card.html",
{
"game": game,
"gameform": GameForm(instance=game, auto_id="id_%s_" + uuid.uuid4().hex),
"bookingform": BookingForm(
initial={"game": game}, auto_id="id_%s_" + uuid.uuid4().hex
),
},
request=request,
)
return {
"form_html": form_html,
"game_html": game_html,
"nav_html": _get_nav_html(game, request),
"order": _get_game_order(game),
}
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 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 test_booking_form_name_label(self):
form = BookingForm()
self.assertEquals(form.fields['name'].label, 'Имя')
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_booking_form_phone_label(self):
form = BookingForm()
self.assertEquals(form.fields['phone'].label, 'Телефон')
def test_booking_form_comment_label(self):
form = BookingForm()
self.assertEquals(form.fields['comment'].label, 'Комментарий')
def test_booking_form_work_label(self):
form = BookingForm()
self.assertEquals(form.fields['work'].label, 'Услуга')
def test_booking_form_address_label(self):
form = BookingForm()
self.assertEquals(form.fields['address'].label, 'Адрес')
def test_booking_form_time_label(self):
form = BookingForm()
self.assertEquals(form.fields['time'].label, 'Время')
def test_booking_form_date_label(self):
form = BookingForm()
self.assertEquals(form.fields['date'].label, 'Дата')
def test_form_is_valid(self):
form = BookingForm(data=self.parameters)
self.assertTrue(form.is_valid())
