def new_tagged_booking(step, booking_name, building, place_name, start_date,
end_date, username, tag):
booking = Booking()
booking.user = User()
booking.user = User.objects.get(username=username)
booking.name = booking_name
booking.start_date = start_date
booking.end_date = end_date
booking.place = Place()
booking.place.name = place_name
booking.place.building = Building()
booking.place.building.name = building
booking.responsible = username
booking.save()
tag_o = Tag(name=tag)
tag_o.save()
booking.tags.add(tag_o)
for day in range(0, 10):
book = BookTime()
book.date_booking = parser.parse(start_date) + timedelta(days=day)
book.start_hour = "20:00"
book.end_hour = "22:00"
book.save()
booking.time.add(book)
booking.save()
def book(request):
pickup_location = request.session['pickup_location']
dropoff_location = request.session['dropoff_location']
pickup_date = request.session['pickup_date']
dropoff_date = request.session['dropoff_date']
pickup_time = request.session['pickup_time']
dropoff_time = request.session['dropoff_time']
driver = request.session['driver']
username = request.session['name1']
car_id = request.session['car_id']
s = Booking(car_id=car_id,
pickup_location=pickup_location,
dropoff_location=dropoff_location,
pickup_date=pickup_date,
dropoff_date=dropoff_date,
pickup_time=pickup_time,
dropoff_time=dropoff_time,
driver=driver,
username=username)
s.save()
subject = 'Confirmation Mail For Booking'
message = 'Your booking details are below.' + '\n' + '\nCar_id:' + car_id + '\nPickuplocation:' + pickup_location + '\nPickupDate:' + pickup_date + '\nPickupTime:' + pickup_time + ':00' + '\nDropoffLocation:' + dropoff_location + '\nDropoffDate:' + dropoff_date + '\nDropoffTime:' + dropoff_time + ':00' + '\nDriver:' + driver
from_email = settings.EMAIL_HOST_USER
to_list = [request.session['email']]
send_mail(subject, message, from_email, to_list, fail_silently=True)
booking = Booking.objects.filter(username=username)
del request.session['pickup_location']
del request.session['dropoff_location']
del request.session['pickup_date']
del request.session['dropoff_date']
del request.session['pickup_time']
del request.session['dropoff_time']
del request.session['driver']
del request.session['car_id']
return HttpResponseRedirect('/booking/bookingHistory/')
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 form_valid(self, form):
if not self.request.user.is_authenticated:
messages.add_message(self.request, messages.ERROR,
'You need to be logged in to book a Pod.')
return super(BookingFormView, self).form_invalid(form)
user = self.request.user
booking = Booking(start=form.cleaned_data['start'],
end=form.cleaned_data['end'],
purpose=form.cleaned_data['purpose'],
installer=form.cleaned_data['installer'],
scenario=form.cleaned_data['scenario'],
resource=self.resource,
user=user)
try:
booking.save()
except ValueError as err:
messages.add_message(self.request, messages.ERROR, err)
return super(BookingFormView, self).form_invalid(form)
try:
if settings.CREATE_JIRA_TICKET:
create_jira_ticket(user, booking)
except JIRAError:
messages.add_message(
self.request, messages.ERROR, 'Failed to create Jira Ticket. '
'Please check your Jira '
'permissions.')
booking.delete()
return super(BookingFormView, self).form_invalid(form)
messages.add_message(self.request, messages.SUCCESS, 'Booking saved')
return super(BookingFormView, self).form_valid(form)
def save(self, *args, **kwargs): # Saving the no. of days automatically from departure_date and arrival_date days_diff = self.arrival_date - self.departure_date diff = int(days_diff.days) self.no_of_days = diff # Saving the no. of person automatically by counting adult, children and infant self.total_person = int(self.no_of_adult + self.no_of_children + self.no_of_infant) if self.pk is not None and self.marketing_confirmation_status: print "update_form" # print self.accomodation if(self.marketing_confirmation_status): b = Booking.objects.filter(created_date__startswith = datetime.date.today()).count() if(self.created_date.month >= 10): month = str(self.created_date.month) else: month = '0' + str(self.created_date.month) if(self.created_date.day >= 10): day = str(self.created_date.day) else: day = '0' + str(self.created_date.day) book = Booking(customer = self.customer, remarks = self.remarks, departure_date = self.departure_date, arrival_date = self.arrival_date, no_of_days = self.no_of_days, no_of_nights = self.no_of_nights, no_of_adult = self.no_of_adult, no_of_infant = self.no_of_infant, no_of_children = self.no_of_children, total_person = self.total_person, booking_id = 'BOOKID' + '_' + unicode(day + month + str(self.created_date.year)) + '_' + str(b+1)) # myMovieGenre = Movie_Info_genre.objects.create(genre='horror') # accomodation = AccomodationStar.objects.create(accomodation_star = ) book.save() # for item in self.accomodation: # book.accomodation.add(item) super(Marketing, self).save(*args, **kwargs)
def run():
# Delete db
dealers = Dealer.objects.all()
dealers.delete()
vehicles = Vehicle.objects.all()
vehicles.delete()
bookings = Booking.objects.all()
bookings.delete()
json_data = open("datafile/dataset.json")
data1 = json.load(json_data)
# Create and save dealers
for dealer in data1["dealers"]:
dealer_to_save = Dealer()
dealer_to_save.id = dealer["id"]
dealer_to_save.name = dealer["name"]
dealer_to_save.latitude = dealer["latitude"]
dealer_to_save.longitude = dealer["longitude"]
times = ""
for time in dealer["closed"]:
times = times + time + " "
dealer_to_save.closed = times.rstrip()
dealer_to_save.save()
# Create and save vehicles
for vehicle in dealer["vehicles"]:
vehicle_to_save = Vehicle()
vehicle_to_save.id = vehicle["id"]
vehicle_to_save.dealerId = dealer_to_save
vehicle_to_save.model = vehicle["model"]
vehicle_to_save.fuel = vehicle["fuel"]
vehicle_to_save.transmission = vehicle["transmission"]
# Create availability strings
availability_to_save = ""
for availability in vehicle["availability"]:
availability_to_save += availability
times = " "
for time in vehicle["availability"][availability]:
times += time + " "
availability_to_save += times.rstrip() + "\n"
vehicle_to_save.availability = availability_to_save
vehicle_to_save.save()
# Create booking
for booking in data1["bookings"]:
booking_to_save = Booking()
booking_to_save.id = booking["id"]
booking_to_save.firstName = booking["firstName"]
booking_to_save.lastName = booking["lastName"]
booking_to_save.vehicleId = Vehicle.objects.get(
id=booking["vehicleId"])
booking_to_save.pickupDate = datetime.strptime(booking["pickupDate"],
'%Y-%m-%dT%H:%M:%S')
booking_to_save.createdAt = datetime.strptime(booking["createdAt"],
'%Y-%m-%dT%H:%M:%S.%f')
booking_to_save.save()
json_data.close()
def Book(request, *args, **kwargs):
#API to check in to park
#Needed parameters: userID and locationID
if (request.method == 'POST'):
user_id = request.POST.get('userID')
u = User.objects.get(userID=user_id)
location_id = request.POST.get('locationID')
lot = Lot.objects.get(lotID=location_id)
if (User.objects.filter(userID=user_id) and (u.userType >= lot.auth)
and not Booking.objects.filter(user=u, status="Reserved")):
time = request.POST.get('bookingTime')
bookingPrice = 5000
if (u.userBalance >= bookingPrice) and (lot.capacity > 0):
b = Booking(user=(User.objects.get(userID=user_id)),
location=lot,
bookingTime=time,
status="Reserved")
if (lot.lotID == "Motor_Sipil" or lot.lotID == "Motor_SR"
or lot.lotID == "Mobil_SR"):
lot.capacity -= 1
lot.save()
b.save()
u.userBalance = u.userBalance - bookingPrice
u.save()
#Send Check In Notification
subject = 'Your booking are reserved!'
message = 'Congratulations! \nYour booking at ' + str(
b.location.lotName
) + ' is reserved from ' + str(
b.bookingTime
) + ' until 1 hour after that. \nThe booking will cost you IDR 5,000 exclude parking fees.'
to_list = [b.user.userEmail]
send_mail(subject,
message,
settings.EMAIL_HOST_USER,
to_list,
fail_silently=True)
#Generate output
output = {
'bookingID': str(b.bookingID),
'bookingTime': str(b.bookingTime),
'location': str(b.location.lotName),
}
return JsonResponse(output)
else:
return HttpResponseBadRequest("ERR: Booking failed")
else:
return HttpResponseBadRequest("ERR: You are not allowed to book")
else:
return HttpResponseForbidden(
"ERR: You are not allowed to access this endpoint.")
def mutate(self, info, booking_data):
if info.context.user.is_anonymous:
raise GraphQLError('User not authenticated')
customer = Customer.objects.get(id=booking_data.customer_id)
property = Property.objects.get(id=booking_data.property_id)
booking = Booking(property=property, customer=customer,
message=booking_data.booking_message)
booking.save()
return CreateBooking(booking=booking)
def make_booking_in_past(start_date, end_date, title):
"""Save a booking without cleaning (validating) the data."""
b = Booking(**dict(
start_date=start_date,
end_date=end_date,
title=title,
))
b.save()
return b
def create(self, validated_data):
booking = Booking(
user=validated_data.get('user'),
number_of_passengers=validated_data.get('number_of_passengers'),
bus_route=validated_data.get('bus_route'),
destination=validated_data.get('destination'),
amount_paid=validated_data.get('amount_paid'))
booking.save()
return booking
def test_is_current_in_the_past(self):
"""A simple booking."""
today = datetime.today().date()
last_week = today + timedelta(days=-7)
b = Booking(**dict(
start_date=last_week,
end_date=last_week + timedelta(days=3),
title='Three days in the sun'
))
b.save()
self.assertFalse(b.is_current())
def test_repeatBooking(self, repeat=True):
dayofweek = 0 # day_map[form.cleaned_data['dayID'].upper()]
cleaned_data = self.data
start = cleaned_data['start']
end = cleaned_data['end']
year = int(start.year)
month = int(start.month)
day = int(start.day) #[8:10])
loc = cleaned_data['location']
s_time = str(start)[-8:] #get time substring
e_time = str(end)[-8:]
title = cleaned_data['title']
descr = cleaned_data['description']
b_list = []
if True:
cal = Calendar()
ydcal = cal.yeardays2calendar(year, width=6)
if month > 5:
w = ydcal[1]
else:
w = ydcal[0]
for m in range(len(w)):
if m + 1 < month:
continue #skip past months
for k in range(len(w[m])): #week in a month
for d in range(len(w[m][k])): #days in a week
cal_day = w[m][k][d]
if (cal_day[0] < day
and m + 1 == month) or cal_day[0] == 0:
continue
if cal_day[1] == dayofweek:
# print("here")
if m < 9: #format month
cal_m = "0" + str(m + 1)
else:
cal_m = str(m + 1)
if cal_day[0] < 9: #format day
cal_d = "0" + str(cal_day[0])
else:
cal_d = str(cal_day[0])
date_format = str(year) + "-" + cal_m + "-" + cal_d
start_rec = date_format + " " + s_time
end_rec = date_format + " " + e_time
b = Booking(location=loc,
start=start_rec,
end=end_rec,
title=title,
description=descr)
b.save()
b_list.append(b)
self.assertTrue(False)
return b_list
def addBooking(request):
booking_id = request.POST.get('booking_id')
booking_title = request.POST.get('booking_title')
booking_type = request.POST.get('booking_type')
booking_date = request.POST.get('booking_date')
booking_desc = request.POST.get('booking_desc')
add_booking = Booking(booking_id=booking_id,
booking_title=booking_title,
booking_type=booking_type,
booking_date=booking_date,
booking_description=booking_desc)
add_booking.save()
return showBooking(request)
def booking(request, pk=None):
if request.method == "POST":
if pk:
hotel = Hotel.objects.get(pk=pk)
guest = request.user
check_in = request.POST['check_in_date']
check_out = request.POST['check_out_date']
no_of_guest = request.POST['bookingGuest']
if not no_of_guest.isdigit():
messages.error(request, 'Please Enter valid No of Guests.')
return redirect(home)
# check wether the dates are valid
# case 1: a room is booked before the check_in date, and checks out after the requested check_in date
case_1 = Booking.objects.filter(hotel=hotel,
check_in__lte=check_in,
check_out__gte=check_in).exists()
# case 2: a room is booked before the requested check_out date and check_out date is after requested check_out date
case_2 = Booking.objects.filter(hotel=hotel,
check_in__lte=check_out,
check_out__gte=check_out).exists()
case_3 = Booking.objects.filter(hotel=hotel,
check_in__gte=check_in,
check_out__lte=check_out).exists()
# if either of these is true, abort and render the error
if case_1 or case_2 or case_3:
messages.warning(
request,
'The room is not available on your selected dates')
return redirect(home)
# dates are valid
booking = Booking(
hotel=hotel,
guest=guest,
no_of_guest=no_of_guest,
check_in=check_in,
check_out=check_out,
)
booking.save()
messages.success(request,
'Your Hotel has been Booked Successfully!')
return redirect(dashboard)
return render(request, 'users/home.html')
def test_booking_creation(self):
time_period = datetime.timedelta(30)
b = Booking()
b.user = self.test_user
b.start_date = datetime.datetime.now()
b.end_date = datetime.datetime.now()+time_period
b.save()
items = Kit.objects.all()
b.kits = items
b.save()
def booking(request):
template_name = 'app/booking-single.html'
context = {'demo': "demo"}
if request.method == "POST":
hotel_id = request.POST['hotel_id']
hotel = request.POST['hotel']
name = request.POST['name']
email = request.POST['email']
phone = request.POST['phone']
person = request.POST['person']
message = request.POST['msg']
user_id = request.POST['user_id']
enq = Booking(hotel_id=hotel_id, hotel=hotel, name=name, email=email, phone=phone, person=person,
message=message, user_id=user_id)
enq.save()
# send_mail(
# 'Tour Enquiry for ' + tour.id,
# 'There has been an enquiry for '+ tour.city_name + tour.id + 'for more detail please login in admin panel.',
# '*****@*****.**',
# [email, '*****@*****.**'],
# fail_silently=False
# )
# sender = '*****@*****.**'
# recipient = '*****@*****.**'
# msg = MIMEText("Message text")
# msg = MIMEMultipart('alternative')
# msg['Subject'] = "Tour Enquiry for " + tour_id
# # msg['From'] = sender
# msg['To'] = recipient
#
# html = message
#
# part2 = MIMEText(html, 'html')
# msg.attach(part2)
# server = smtplib.SMTP_SSL('smtp.zoho.com', 465)
# server.login('*****@*****.**', 'Finflock123!')
# server.sendmail(sender, [msg['To']], msg.as_string())
# server.quit()
messages.success(request, "Your enquiry has been submitted, our representative will call you!!!")
# tours = Tour.objects.filter(available=True)
# context = {"msg": "Your enquiry has been submitted, our representative will call you!!!"}
return render(request, template_name, context)
else:
return render(request, template_name, context)
def create(self, validated_data):
email = validated_data.pop('email')
first_name = validated_data.pop('name')
personal_number = validated_data.pop('personal_number')
user_obj, created = User.objects.get_or_create(email=email)
if created:
user_obj.username = email
user_obj.first_name = first_name
user_obj.profile.personal_number = personal_number
user_obj.save()
# print(validated_data)
booking = Booking(user=user_obj, **validated_data)
booking.save()
return booking
def booking(request):
if request.method == 'POST':
form = DateForm(request.POST)
if form.is_valid():
new_booking = Booking()
new_booking.date = form.cleaned_data['date']
new_booking.seats = form.cleaned_data['seats']
new_booking.info = form.cleaned_data['info']
new_booking.phone_number = form.cleaned_data['phone_number']
opendate = OpenDate.objects.get(date = form.cleaned_data['date'])
remaining = opendate.seats - int(form.cleaned_data['seats'])
if remaining == 0:
opendate.seats -= int(form.cleaned_data['seats'])
opendate.is_booked = 1
elif remaining == 1:
opendate.seats = 0
opendate.is_booked = 1
else:
opendate.seats = remaining
opendate.save()
new_booking.save()
request.session['form-submitted'] = True
try:
send_mail(
subject = "Booking for " + new_booking.date.strftime('%Y-%m-%d'),
message = "A booking for " + new_booking.seats + " seats on " + new_booking.date.strftime('%Y-%m-%d') + " was made.",
from_email = "*****@*****.**",
recipient_list = ['*****@*****.**']
)
except BadHeaderError:
return HttpResponse('Invalid header found.')
return redirect('confirmation')
else:
form = DateForm(initial = {'information' : 'Please enter all the information necessary as explained above.\nAny incomplete booking or without enough information will be automatically cancelled.'})
dates = OpenDate \
.objects \
.filter(date__gte=datetime.date.today()) \
.filter(is_booked = False)
if dates:
empty = 0
else:
empty = 1
return render(request, 'booking/booking.html', dict(form=form, empty=empty))
def registered_booking(request):
user_cart = Cart.objects.all()
item_list = Item.objects.filter(cart = user_cart)
mailing_list = Mail.objects.all()
total_price=0
if request.user.is_authenticated():
user=request.user
custom_user = CustomUser.objects.get(user=user)
for item in item_list:
total_price += item.product.price
#Unblock on production
#discount_total_price = total_price*(custom_user.discount/100)
discount_total_price = total_price*0.2
booking_item = Booking(name = "Заказ номер" + " " + str(1), user_name = user. first_name, user_sec_name=user.last_name, user_mail=user.email, user_phone = custom_user.phone, total_sum=discount_total_price)
booking_item.save()
for item in item_list:
booking_item.items.add(item)
return HttpResponseRedirect("/thanx/")
def test_edit_inplace(self):
s1 = "2018-05-15 12:00:00"
s2 = "2018-05-15 13:00:00"
s3 = s1
s4 = "2018-05-15 16:00:00"
e1 = "2018-05-15 17:00:00"
e2 = "2018-05-15 14:00:00"
e3 = "2018-05-15 15:00:00"
Booking.objects.create(location=self.location,
start=s1,
end=e1,
description="first")
b2 = Booking(location=self.location,
start=s2,
end=e2,
description="second")
b2.save()
b3 = Booking(location=self.location, start=s3, end=e3)
b3.save()
print(b2.start)
self.assertGreater(b3.queueNo, b2.queueNo)
def test_edit(self):
b1 = Booking(location=self.location,
start=self.s1,
end=self.e1,
description=self.d1)
b1.save()
b2 = Booking(location=self.location,
start=self.s2,
end=self.e2,
description=self.d2)
b2.save()
qNo1 = b2.queueNo
#update second booking
b2.start = self.s3
b2.start = self.e3
b2.save()
qNo2 = b2.queueNo
print("before ", qNo1)
print("after", qNo2)
self.assertGreater(qNo1, qNo2)
import dateutil.parser prop = Property.objects.get(code='A902') admin = User.objects.get(pk=1) Booking.objects.all().delete() book = Booking() book.created_by = admin book.modified_by = admin book.created_on = datetime.now() book.modified_on = datetime.now() book.property = prop book.from_date = '2017-06-16' book.to_date = '2017-06-18' book.state = Booking.FULL_PAID book.save() book = Booking() book.created_by = admin book.modified_by = admin book.created_on = datetime.now() book.modified_on = datetime.now() book.property = prop book.from_date = '2017-06-18' book.to_date = '2017-06-23' book.state = Booking.PEND_PAY book.save() book = Booking() book.created_by = admin book.modified_by = admin
class CheckAvailabilityWiewTests(TestCase):
def setUp(self):
self.url = reverse('booking:check_availability')
self.client = Client()
self.password = '******'
self.datetime = timezone.make_aware(
datetime.now(),
timezone.get_current_timezone()).replace(microsecond=0)
self.restaurant = Restaurant.objects.create(
name='da mario',
city='vignola',
address='via baracchini, 95',
n_places=50,
booking_duration=120)
restaurant_position = get_coordinates(self.restaurant.city + ', ' +
self.restaurant.address)
self.restaurant.latitude = restaurant_position['lat']
self.restaurant.longitude = restaurant_position['lng']
self.restaurant.save()
self.client_user = User.objects.create(first_name='paolo',
last_name='verdi',
email='*****@*****.**',
username='******',
user_type=User.TYPES[0][0])
self.client_user.set_password(self.password)
self.client_user.save()
self.restaurant_user = User.objects.create(
first_name='mario',
last_name='rossi',
email='*****@*****.**',
username='******',
user_type=User.TYPES[1][0],
restaurant_information=self.restaurant)
self.restaurant_user.set_password(self.password)
self.restaurant_user.save()
self.booking = Booking(client=self.client_user,
restaurant=self.restaurant,
start_time=self.datetime,
n_places=2,
state=Booking.STATES[1][0])
self.booking.end_time = self.booking.calculate_end_time()
def test_client_logged_ajax_call(self):
response = self.client.post(self.url, {},
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(response.status_code, 200)
def test_client_logged_no_ajax_call(self):
response = self.client.post(self.url, {})
self.assertEqual(response.status_code, 404)
def test_client_logged_ajax_call_with_data(self):
self.booking.save()
self.client.login(username=self.client_user.username,
password=self.password)
data = {
'restaurant_id': self.restaurant.id,
'n_places': 10,
'start_time': self.datetime.strftime("%Y-%m-%d-%H-%M-%S")
}
data_result = {'result': 'success', 'state': Booking.STATES[1][0]}
response = self.client.post(self.url,
data,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(str(response.content, encoding='utf8'),
data_result)
def test_client_logged_ajax_call_without_data(self):
data = {
'restaurant_id': 0,
'n_places': 10,
'start_time': self.datetime.strftime("%Y-%m-%d-%H-%M-%S")
}
data_result = {'result': 'error'}
response = self.client.post(self.url,
data,
HTTP_X_REQUESTED_WITH='XMLHttpRequest')
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(str(response.content, encoding='utf8'),
data_result)
class ClientBookingsWiewTests(TestCase):
def setUp(self):
self.url = reverse('booking:client_bookings')
self.client = Client()
self.password = '******'
self.datetime = timezone.make_aware(
datetime.now(),
timezone.get_current_timezone()).replace(microsecond=0)
self.restaurant = Restaurant.objects.create(
name='da mario',
city='vignola',
address='via baracchini, 95',
n_places=50,
booking_duration=120)
restaurant_position = get_coordinates(self.restaurant.city + ', ' +
self.restaurant.address)
self.restaurant.latitude = restaurant_position['lat']
self.restaurant.longitude = restaurant_position['lng']
self.restaurant.save()
self.client_user = User.objects.create(first_name='paolo',
last_name='verdi',
email='*****@*****.**',
username='******',
user_type=User.TYPES[0][0])
self.client_user.set_password(self.password)
self.client_user.save()
self.restaurant_user = User.objects.create(
first_name='mario',
last_name='rossi',
email='*****@*****.**',
username='******',
user_type=User.TYPES[1][0],
restaurant_information=self.restaurant)
self.restaurant_user.set_password(self.password)
self.restaurant_user.save()
self.booking = Booking(client=self.client_user,
restaurant=self.restaurant,
start_time=self.datetime,
n_places=2,
state=Booking.STATES[1][0])
self.booking.end_time = self.booking.calculate_end_time()
def test_not_logged_user(self):
response = self.client.get(self.url)
expected_url = reverse('login') + '?next=' + self.url
self.assertRedirects(response,
expected_url,
status_code=302,
target_status_code=200)
def test_restaurant_logged(self):
self.restaurant_user.client_information = self.restaurant
self.restaurant_user.save()
self.client.login(username=self.restaurant_user.username,
password=self.password)
response = self.client.get(self.url)
expected_url = reverse('login') + '?next=' + self.url
self.assertRedirects(response,
expected_url,
status_code=302,
target_status_code=200)
def test_client_logged_without_results(self):
self.client.login(username=self.client_user.username,
password=self.password)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertQuerysetEqual(response.context['booking_list'], [])
def test_client_logged_with_results(self):
self.booking.save()
self.client.login(username=self.client_user.username,
password=self.password)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['booking_list'][0], self.booking)
def test_booking_before_now(self):
self.booking.start_time = self.datetime - timedelta(minutes=1)
self.booking.save()
self.client.login(username=self.client_user.username,
password=self.password)
response = self.client.get(self.url)
self.assertEqual(response.status_code, 200)
self.assertQuerysetEqual(response.context['booking_list'], [])
class SimpleTest(TestCase):
def setUp(self):
# User objects.Non auth user
self.user1 = OAuthUser.objects.create_user("temporary", "*****@*****.**", "temporary")
# Auth user
self.user2 = OAuthUser.objects.create_user("temporary2", "*****@*****.**", "temporary")
self.user2.is_auth = True
self.user2.save()
# Auth user
self.user3 = OAuthUser.objects.create_user("temporary3", "*****@*****.**", "temporary")
self.user3.is_banned = True
self.user3.save()
# Create Booking object
self.order = Booking(
user=self.user2,
swim_lane=3,
start_date=datetime.datetime.now().date(),
start_time="11:30:00",
end_time="12:00:00",
)
self.order.save()
# non exists order id
self.fake_id = 9999
self.client = Client()
def tearDown(self):
self.user1.delete()
self.user2.delete()
self.order.delete()
########################
# List of orders - GET #
########################
def test_get_booking_list(self):
url = reverse("booking_list_api")
# Get by non login user
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
# Get by no auth user
self.client.login(email="*****@*****.**", password="******")
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
# Get by banned user
self.client.login(email="*****@*****.**", password="******")
response = self.client.get(url)
self.assertEqual(response.status_code, 403)
# Get by auth user
self.client.login(email="*****@*****.**", password="******")
response = self.client.get(url)
self.assertEqual(response.status_code, 200)
#########################
# List of orders - POST #
#########################
def test_post_booking_list(self):
url = reverse("booking_list_api")
post = {"start_date": datetime.datetime.now().date(), "start_time": "11:30:00", "end_time": "12:00:00"}
post_invalid_date_max = {
"start_date": datetime.datetime.now().date() + datetime.timedelta(days=6),
"start_time": "11:30:00",
"end_time": "12:00:00",
}
post_invalid_date_min = {
"start_date": datetime.datetime.now().date() - datetime.timedelta(days=2),
"start_time": "11:30:00",
"end_time": "12:00:00",
}
post_invalid_time = {
"start_date": datetime.datetime.now().date(),
"start_time": "11:31:00",
"end_time": "12:00:00",
}
# Post by non login user
response = self.client.post(url, post)
self.assertEqual(response.status_code, 403)
# Post by no auth user
self.client.login(email="*****@*****.**", password="******")
response = self.client.post(url, post)
self.assertEqual(response.status_code, 403)
# Post by banned user
self.client.login(email="*****@*****.**", password="******")
response = self.client.post(url, post)
self.assertEqual(response.status_code, 403)
# Post by auth user
self.client.login(email="*****@*****.**", password="******")
response = self.client.post(url, post)
self.assertEqual(response.status_code, 201)
# Post by auth user with invalid date - max
response = self.client.post(url, post_invalid_date_max)
self.assertEqual(response.status_code, 400)
# Post by auth user with invalid date - post past date
response = self.client.post(url, post_invalid_date_min)
# print(response.content)
self.assertEqual(response.status_code, 400)
# Post by auth user with invalid time
response = self.client.post(url, post_invalid_time)
self.assertEqual(response.status_code, 400)
# Post if fully booked at this time(6 lines)
self.client.post(url, post) # 3
self.client.post(url, post) # 4
self.client.post(url, post) # 5
self.client.post(url, post) # 6
response = self.client.post(url, post) # 7
self.assertEqual(response.status_code, 400)
def test_delete_order(self):
url_detail = reverse("booking_detail_api", args=(self.order.id,))
# delete order by no login user
response = self.client.delete(url_detail)
self.assertEqual(response.status_code, 403)
# delete order by no auth user
self.client.login(email="*****@*****.**", password="******")
response = self.client.delete(url_detail)
self.assertEqual(response.status_code, 403)
"""
# delete order by auth user, but no owner this order
self.client.login(email='*****@*****.**', password='******')
response = self.client.delete(url_detail)
self.assertEqual(response.status_code, 403)
"""
# delete order by auth user and owner this order
self.client.login(email="*****@*****.**", password="******")
response = self.client.delete(url_detail)
self.assertEqual(response.status_code, 204)
class test_booking(TestCase):
def setUp(self):
self.loc = Location.objects.create(
name="BroGym",
address="Brophessor st. 12",
description=
"best gym get swole 100\%\ gains guaranteed live large die large leave a huge coffin"
)
self.user = User.objects.create_superuser(customer_number="92837465",
email="*****@*****.**",
password="******")
self.b1 = Booking(id=1,
person=self.user,
title="Baiceps",
description="get de big baiceps",
location=self.loc,
start="2019-05-15T12:00:00Z",
end="2019-05-15T14:00:00Z")
self.b1.save()
self.b2 = Booking(id=2,
person=self.user,
title="legs",
description="skip legday",
location=self.loc,
start="2019-05-15T12:00:00Z",
end="2019-05-15T14:00:00Z")
self.b2.save()
def test_name(self):
self.assertTrue(str(self.b1) == "Baiceps")
def test_absolute_url(self):
pass
def test_move_queue(self):
before1 = self.b1.queueNo
before2 = self.b2.queueNo
queue = [self.b1, self.b2]
self.b1.move_queue(queue, 1)
self.assertGreater(self.b1.queueNo, before1)
self.assertGreater(self.b2.queueNo, before2)
def test_save(self):
before = self.b2.queueNo
self.b2.start = datetime(2019, 5, 15, 14) #'2019-05-15T14:00:00Z'
self.b2.end = datetime(2019, 5, 15, 16) #'2019-05-15T16:00:00Z'
self.b2.save()
self.assertGreater(before, self.b2.queueNo)
def test_delete(self):
before = self.b2.queueNo
self.b1.delete()
q1 = Booking.objects.all()[0]
self.assertGreater(before, q1.queueNo)
def test_get_groups(self):
groups = self.b1.get_groups()
self.assertEqual([], groups)
def test_get_date(self):
pass
def create_booking(self, visit, guest):
booking = Booking()
booking.visit = visit
booking.booker = guest
booking.save()
return booking
def book(request, id):
bookable = get_object_or_404(Bookable, pk=id)
if request.method == 'POST':
booking = Booking(
bookable=bookable,
owner=request.user,
start=make_aware(
datetime.strptime(request.POST['start'], "%Y-%m-%d")),
end=make_aware(
datetime.strptime(request.POST['end'], "%Y-%m-%d") +
timedelta(hours=23, minutes=59, seconds=59)
), # book to end of day
comment=request.POST['comment'])
try:
if bookable.status != 'active':
raise ValidationError(
{'__all__': 'Host is not currently bookable.'})
if booking.start.date() < now().date():
raise ValidationError(
{'start': 'Booking cannot start in the past.'})
if booking.end.date() < now().date():
raise ValidationError(
{'end': 'Booking cannot end in the past.'})
if bookable.check_reserved():
raise ValidationError(
{'__all__': "Item is currently reserved."})
if (booking.end - booking.start) > timedelta(days=31):
raise ValidationError({
'end':
"Bookings have a maximum duration of one month (31 days). You may want to reserve this machine instead."
})
booking.save()
except ValidationError as e:
form = BookingForm(instance=booking)
form.errors.update(e)
availability = getcalendarsummary(bookable.get_calendar(),
bookable.get_reservations())
return render(request, 'www/booking/book.html', {
'form': form,
'availability': availability,
'bookable': bookable,
})
mail.send_booking_confirmation(booking)
messages.success(request, 'Booking created.')
return redirect(host, id)
availability = getcalendarsummary(bookable.get_calendar(),
bookable.get_reservations())
form = BookingForm()
return render(request, 'www/booking/book.html', {
'form': form,
'availability': availability,
'bookable': bookable,
})
def save(self, user, force_insert=False, force_update=False, commit=True):
booking = Booking()
booking.user = user
booking.name = self.cleaned_data.get("name")
booking.start_date = self.cleaned_data.get("start_date")
booking.end_date = self.cleaned_data.get("end_date")
booking.place = self.cleaned_data.get("place")
weekdays = self.cleaned_data.get("week_days")
#if user.profile_user.is_admin():
# booking.engineering = self.cleaned_data.get("engineering_choice")
# booking.responsible = self.cleaned_data.get("responsible")
# name = re.search('[a-zA-Z0-9_.+-]+@[a-zA-Z0-9-]+\.[a-zA-Z0-9-.]+',
# booking.responsible)
# if name is not None:
# name = name.group()
# users = User.objects.filter(username=name)
# ONE_FOUND = 1
# if user.profile_user.is_admin() and (users.count() is ONE_FOUND):
# booking.user = users[0]
#else:
# booking.engineering = user.profile_user.engineering
# booking.responsible = str(user.profile_user)
book = BookTime()
book.date_booking = booking.start_date
book.start_hour = self.cleaned_data.get("start_hour")
book.end_hour = self.cleaned_data.get("end_hour")
try:
booking.save()
if booking.exists(book.start_hour, book.end_hour, weekdays):
booking.delete()
return None
else:
for day in date_range(book.date_booking, booking.end_date):
if (day.isoweekday() - 1 in map(int, weekdays)):
newBookTime = BookTime(start_hour=book.start_hour,
end_hour=book.end_hour,
date_booking=day)
newBookTime.save()
booking.time.add(newBookTime)
#tags = self.cleaned_data['tags']
#if tags:
# tags = ast.literal_eval(tags)
# for name in tags:
# if not Tag.objects.filter(name=name).exists():
# tag = Tag(name=name)
# tag.save()
# tag = Tag.objects.get(name=name)
# booking.tags.add(tag)
#booking.save()
except Exception as e:
booking.delete()
msg = _('Failed to book selected period')
print(e)
raise forms.ValidationError(msg)
return None
return booking
