class ReservationRepo(object):
lx = [
Reservation('Alice', 'Board Room'),
Reservation('Bob', 'Lecture Hall'),
Reservation('Joe', 'Meeting Room 1')
]
items = {}
@classmethod
def init(cls):
for o in cls.lx:
cls.add_reservation(o)
@classmethod
def add_reservation(cls, o):
assert isinstance(o, Reservation)
if o.reservation_id == 0:
key = len(cls.items)
for k, v in cls.items.items():
if str(k) == str(key):
key += 1
o.reservation_id = key
cls.items[str(o.reservation_id)] = o
return o
@classmethod
def delete_reservation(cls, id):
del cls.items[str(id)]
def test_model_eq(self):
resource1 = Resource(ID=1, name="Resource1", resource_type="ROOM")
resource2 = Resource(ID=1, name="Resource1", resource_type="ROOM")
resource3 = Resource(ID=1, name="Resource3", resource_type="ROOM")
self.assertEqual(resource1, resource2)
self.assertNotEqual(resource1, resource3)
date = QtCore.QDate.currentDate()
start_time = QtCore.QTime(8, 0)
end_time = QtCore.QTime(9, 0)
start = QtCore.QDateTime(date, start_time)
end = QtCore.QDateTime(date, end_time)
reservation1 = Reservation(ID=1,
resource=resource1,
start=start,
end=end)
reservation2 = Reservation(ID=1,
resource=resource2,
start=start,
end=end)
reservation3 = Reservation(ID=1,
resource=resource3,
start=start,
end=end)
self.assertEqual(reservation1, reservation2)
self.assertNotEqual(reservation1, reservation3)
def setUp(self):
self.user = User.objects.create(first_name="Zeeshan",
last_name="Abid",
password="******",
email="*****@*****.**")
one_day = 60 * 60 * 24
self.reservation_1 = Reservation(
start_date=int(time.time()) + 2 * one_day,
end_date=int(time.time()) + 4 * one_day)
self.reservation_2 = Reservation(
start_date=int(time.time()) + 5 * one_day,
end_date=int(time.time()) + 7 * one_day)
def post(self):
resourceID = self.request.get('resourceID')
resource = ndb.Key(urlsafe = resourceID).get()
reservation = Reservation(parent = resource.key)
reservation.author = user = users.get_current_user()
reservation.numsOfAttendee = int(self.request.get('numsOfAttendee'))
resource.numsAvailable = resource.numsAvailable - int(self.request.get('numsOfAttendee'))
resource.numReservations = resource.numReservations + int(self.request.get('numsOfAttendee'))
#Update the last Reserve Date of this resource
nowStr = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
now = datetime.strptime(nowStr, '%Y-%m-%d %H:%M:%S')
resource.lastReserveDate = now
#Save the resource
resource.put()
#Get the reservation info from page
reservation.author = users.get_current_user()
reservation.name = self.request.get('name').strip()
startDateTimeStr = self.request.get('startDateTime')
endDateTimeStr = self.request.get('endDateTime')
startDateTime = datetime.strptime(startDateTimeStr, '%Y-%m-%d %H:%M:%S')
endDateTime = datetime.strptime(endDateTimeStr, '%Y-%m-%d %H:%M:%S')
reservation.startDateTime = startDateTime
reservation.endDateTime = endDateTime
duration = str(endDateTime - startDateTime)
reservation.duration = duration
# Save the reservation
reservation.put()
send_reserved_mail('*****@*****.**')
# sleep(0.2)
self.redirect('/')
def test_get_reservations(self):
customer = Customer(name='Teemu Teekkari',
email='teemu.teekkari@aalto fi')
service1 = Service(name='service1',
price=10.0,
duration=60.0,
description='service1 description')
service2 = Service(name='service1',
price=10.0,
duration=60.0,
description='service1 description')
self.db.save(service1)
self.db.save(service2)
added_reservations = []
date = QtCore.QDate.currentDate()
resource = Resource(name="Resource1", resource_type="ROOM")
for x in range(8, 19):
start_time = QtCore.QTime(x, 0)
end_time = QtCore.QTime(x, 59)
start = QtCore.QDateTime(date, start_time)
end = QtCore.QDateTime(date, end_time)
new_reservation = Reservation(customer=customer,
resource=resource,
start=start,
end=end,
services=[service1, service2])
self.db.save(new_reservation)
added_reservations.append(new_reservation)
reservations = self.db.get_reservations()
for i in range(len(reservations)):
self.assertEqual(reservations[i], added_reservations[i])
def reserve():
# grab the id from the request and query the appropriate System entry
system_id = request.args.get('system')
system = System.query.get(system_id)
# build the datetime for a reservations
date_list = request.args.get('res_date').split("-")
year = int(date_list[0])
month = int(date_list[1])
day = int(date_list[2])
new_date = date(year, month, day)
new_time = time(int(request.args.get('res_time')))
hours = int(request.args.get('hours'))
new_datetime = datetime.combine(new_date, new_time)
# get username from session
reserved_by = session['name']
# iterate through the hours and create reservations
for hr in range(hours):
r = Reservation(res_datetime = new_datetime + timedelta(hours = hr),
reserved_by = reserved_by,
device = system)
db.session.add(r)
# commit all the records
db.session.commit()
# redirect back to hours page with date specified
return redirect(url_for('hours', date_str = new_date.isoformat()))
def get_reservations(self, date=None, customer=None, start=None, end=None):
try:
reservations = []
if date:
reservation_rows = self.reservations.get_by_date(
date.toString('yyyy-MM-dd'))
elif start and end and customer:
reservation_rows = self.reservations.get_by_dates_and_customer(
start.toString('yyyy-MM-dd hh:mm'),
end.toString('yyyy-MM-dd hh:mm'), customer)
elif start and end:
reservation_rows = self.reservations.get_by_dates(
start.toString('yyyy-MM-dd hh:mm'),
end.toString('yyyy-MM-dd hh:mm'))
elif customer:
reservation_rows = self.reservations.get_by_customer(customer)
else:
reservation_rows = self.reservations.get_all()
for row in reservation_rows:
customer = self.customers.get_by_id(row[1])
resource = self.resources.get_by_id(row[2])
rservices = self.get_services(reservationID=row[0])
reservation = Reservation(row=row,
customer=customer,
resource=resource,
services=rservices)
reservations.append(reservation)
return reservations
except Exception as e:
raise DatabaseError(str(e))
def test_get_range_reservation(self):
one_day = 60 * 60 * 24
current = int(time.time())
start_date = current + 15 * one_day
end_date = current + 17 * one_day
reservation = Reservation(start_date=start_date, end_date=end_date)
reservation.reserve(self.user)
range = Reservation.get_reservation_range(start_date - 10 * one_day,
end_date + 10 * one_day)
self.assertEqual(len(range), 2)
reservation.delete()
start_date = current + 5 * one_day
end_date = current + 7 * one_day
reservation1 = Reservation(start_date=start_date, end_date=end_date)
reservation1.reserve(self.user)
start_date = current + 10 * one_day
end_date = current + 13 * one_day
reservation2 = Reservation(start_date=start_date, end_date=end_date)
reservation2.reserve(self.user2)
range = Reservation.get_reservation_range(current + 2 * one_day,
current + 30 * one_day)
self.assertEqual(len(range), 3)
for r in range:
print r
# self.assertEqual(True, r.can_reserve())
reservation1.delete()
reservation2.delete()
start_date = current + 5 * one_day
end_date = current + 7 * one_day
reservation = Reservation(start_date=start_date, end_date=end_date)
reservation.reserve(self.user)
range = Reservation.get_reservation_range(start_date + 5 * one_day,
end_date + 10 * one_day)
self.assertEqual(len(range), 1)
self.assertEqual(range[0].start_date > end_date, True)
def seatReservation(request):
if request.user.is_authenticated():
jsonObj = json.loads(request.body)
user = UserDetail.objects.get(user__id=request.user.id)
if jsonObj['mobileNo'] != None:
mobileNo = validate_mobile(str(jsonObj['mobileNo']))
if mobileNo == False:
return HttpResponse(json.dumps({
"validation": "Invalid mobile number..!!",
"status": False
}),
content_type="application/json")
else:
return HttpResponse(json.dumps({
"validation": "Enter mobile number..!!",
"status": False
}),
content_type="application/json")
journeyDate = datetime.datetime.fromtimestamp(jsonObj['journeyDate'] /
1000)
reservationQry = Reservation(firstName=jsonObj['firstName'],
lastName=jsonObj['lastName'],
age=jsonObj['age'],
gender=jsonObj['genderId'],
addressLine1=jsonObj['addressLine1'],
addressLine2=jsonObj['addressLine2'],
state=jsonObj['state'],
city=jsonObj['city'],
pinNo=jsonObj['pinNo'],
mobileNo=mobileNo,
journeyDate=journeyDate)
reservationQry.userDetail = user
train = Train.objects.get(id=jsonObj['trainId'])
reservationQry.train = train
reservationQry.coachAndSeatNo = json.dumps(getCoachNo(train))
origin = Station.objects.get(id=jsonObj['originId'])
destination = Station.objects.get(id=jsonObj['destinationId'])
reservationQry.source = origin
reservationQry.destination = destination
pnrNo = generate_prn_number(train)
reservationQry.save()
return HttpResponse(json.dumps({
"validation":
"Your reservation process is completed Successfully.",
"status": True
}),
content_type="application/json")
else:
return HttpResponse(json.dumps({
"validation": "You are not logged in.Please login first.",
"status": False
}),
content_type="application/json")
def test_unique_uuid(self):
reservations = [Reservation() for i in range(10)]
repeat = False
for i in range(len(reservations) - 1):
for j in range(i + 1, len(reservations)):
if reservations[i].uuid == reservations[j].uuid:
repeat = True
self.assertEqual(False, repeat)
def post(self):
resource_id = self.request.get('id')
resource_name = self.request.get('name')
start_time = time(
*map(int,
self.request.get('available_start_time').split(':')))
start_time = datetime.combine(datetime.today(), start_time)
duration = int(self.request.get('duration'))
resource = Resource.query(Resource.id == resource_id).get()
end_time = start_time + timedelta(minutes=duration)
# check time format and availability
has_error = False
msg = ''
# error check
if end_time < start_time:
has_error = True
msg = 'Error, wrong format of start time or duration. Please return to former page to enter correctly.'
elif resource.available_start_time > start_time or \
resource.available_end_time < end_time:
has_error = True
msg = 'Error, resource not available during the selected period. Please return to former page to enter another time period.'
else:
reservations = Reservation.query(
Reservation.resource_id == resource_id).fetch()
for r in reservations:
if not (end_time <= r.start_time or start_time >= r.end_time):
has_error = True
msg = 'Error, reservation conflict. Please return to former page to enter another time period.'
if has_error:
template = JINJA_ENVIRONMENT.get_template('newReservation.html')
template_values = {'msg': msg}
self.response.write(template.render(template_values))
else:
# add reservation if no error
reservation = Reservation()
reservation.id = str(uuid.uuid4())
reservation.user = str(users.get_current_user().email())
reservation.start_time = start_time
reservation.duration = duration
reservation.end_time = end_time
reservation.resource_id = resource_id
reservation.resource_name = resource_name
reservation.put()
resource.last_reservation_time = datetime.now() - timedelta(
minutes=300)
resource.num_reserved += 1
resource.put()
t.sleep(1)
send_mail(resource, reservation)
self.redirect('/')
def zarezerwuj(request):
id_room = request.POST['roomid']
From = str(request.POST['From'])
to = str(request.POST['to'])
date = str(request.POST['date'])
mini = str(request.POST['mini'])
maxi = str(request.POST['maxi'])
error = 0
print(From, mini, to, maxi)
if From == '':
messages.error(request, 'Fill in starting hour')
error = 1
#return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
elif int(From) < int(mini) or int(to) > int(maxi) or int(From) >= int(to):
messages.error(request, 'Hours out of range.')
error = 1
elif int(From) == int(to):
messages.error(request, 'Starting hour must be smaller than ending.')
error = 1
elif int(From) < 0 or int(to) < 0:
print(int(From), int(to))
messages.error(request, 'There is no such hour.')
error = 1
elif int(From) > 23 or int(to) > 24:
print(int(From) > 23, int(to))
messages.error(request, 'There is no such hour.')
error = 1
elif to == '':
messages.error(request, 'Fill in ending hour')
error = 1
#return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
if error == 1:
return HttpResponseRedirect(request.META.get('HTTP_REFERER'))
else:
room = Room.objects.get(name=id_room)
try:
with transaction.atomic():
reservation = Reservation(user=request.user,
room=room,
date=date,
From=From,
to=to)
reservation.save()
except IntegrityError, ValidationError:
pass
if Reservation.objects.get(user=request.user,
room=room,
date=date,
From=From,
to=to):
messages.info(request, 'Your reservation was successful!')
else:
messages.error(request, 'Couldn\'t create reservation!')
return redirect('/mysite/search')
def test_date(self):
p = Reservation(starthour=datetime.strptime('12:30', \
'%H:%M').time(), date=datetime.strptime('11.02.01', \
'%d.%m.%y').date(), room=Room.objects.get(name='Blue'), \
endhour=datetime.strptime('14:30', '%H:%M').time(), \
user=User.objects.get(username='******'))
p.save()
self.assertEqual(Reservation.objects.count(), 1)
p.delete()
self.assertEqual(Reservation.objects.count(), 0)
def add_unpaid_reservation(_, info, **kwargs):
print("kwargs>>", kwargs)
print("info.context['user']>>>", info.context['user'])
current_price = 0
vehicle = Vehicle.objects(id=kwargs['vehicle_id']).first()
user = User.objects(id=info.context['user'].id).first()
parameter_list = ParameterInfo.objects()
base_price = vehicle.default_hourly_rate
start_time = dateutil.parser.parse(kwargs['start_time'])
end_time = dateutil.parser.parse(kwargs['end_time'])
delta = end_time - start_time
if (delta.days >= 3):
#front end reject.
print("reject")
elif (delta.days >= 1 and delta.days <= 2):
current_price += delta.days * 24 * base_price
current_price += math.ceil(delta.seconds / 3600) * base_price
current_price *= (ParameterInfo.objects(
description="24h to 72h").first()).rate
elif (delta.days < 1 and math.ceil(delta.seconds / 3600) >= 11):
current_price += math.ceil(delta.seconds / 3600) * base_price
current_price *= (ParameterInfo.objects(
description="11h to 24h").first()).rate
elif (delta.days < 1 and math.ceil(delta.seconds / 3600) >= 6):
current_price += math.ceil(delta.seconds / 3600) * base_price
current_price *= (ParameterInfo.objects(
description="6h to 10h").first()).rate
elif (delta.days < 1 and math.ceil(delta.seconds / 3600) <= 5):
current_price += math.ceil(delta.seconds / 3600) * base_price
current_price *= (ParameterInfo.objects(
description="below 5h").first()).rate
current_price *= vehicle.vehicle_type.hourly_rate
new_reservation_dict = {
"vehicle": vehicle,
"user": user,
"start_time": kwargs['start_time'],
"end_time": kwargs['end_time'],
"actual_start_time": None,
"actual_end_time": None,
"normal_price": current_price,
"penalty_fee": 0,
"status": "unpaid"
}
newreservation = Reservation(**new_reservation_dict)
newreservation.save()
return newreservation
def book(request):
json_data = json.dumps({"HTTPRESPONSE": 0})
if request.method == "POST":
room = Room.objects.get(pk=request.POST['room_id'])
date = datetime.strptime(request.POST['date'], '%Y-%m-%d')
hours = json.loads(request.POST['hours'])
delta = timedelta(hours=1)
error = False
try:
with transaction.atomic():
for h in hours:
begin = datetime.strptime(h, "%H:%M").time()
end = (datetime.combine(dt.today(), begin) + delta).time()
reservation = Reservation(user=request.user,
room=room,
date=date,
begin_time=begin,
end_time=end)
try:
reservation.clean()
except ValidationError as e:
message = begin.__str__()[:5] + "-" + end.__str__(
)[:5] + " is not available"
json_data = json.dumps({
"HTTPRESPONSE": 0,
"ERROR": message
})
error = True
break
for t in room.freeterm_set.filter(date=date):
if t.begin_time <= begin and t.end_time >= end:
break
left = FreeTerm(room=room,
date=date,
begin_time=t.begin_time,
end_time=begin)
right = FreeTerm(room=room,
date=date,
begin_time=end,
end_time=t.end_time)
t.delete()
if left.begin_time < left.end_time:
left.save()
if right.begin_time < right.end_time:
right.save()
reservation.save()
if not error:
json_data = json.dumps({"HTTPRESPONSE": 1})
except IntegrityError:
messages.error(request, 'Something went wrong')
return HttpResponse(json_data, mimetype="application/json")
def make_res(self, fname, lname, creditcard, num_guests, date_in,
date_out):
client = Client(*self._request.params['client_name'].split(' '),
self._request.params['credit_card_number'])
self.repository.add_client(client)
reservation = Reservation(client.ID, date_in, date_out, num_guests)
self.repository.add_reservation(reservation)
return reservation
def setUp(self):
self.user = User.objects.create(first_name="Zeeshan",
last_name="Abid",
email="*****@*****.**")
self.user2 = User.objects.create(username="******",
first_name="HEllo",
last_name="World",
email="*****@*****.**")
one_day = 60 * 60 * 24
self.reservation_1 = Reservation(
start_date=int(time.time()) + 4 * one_day,
end_date=int(time.time()) + 6 * one_day)
self.reservation_2 = Reservation(
start_date=int(time.time()) + 5 * one_day,
end_date=int(time.time()) + 7 * one_day)
self.reservation_3 = Reservation(
start_date=int(time.time()) + 6 * one_day,
end_date=int(time.time()) + 8 * one_day)
self.reservation_not_min_one = Reservation(
start_date=int(time.time()) + 1 * one_day,
end_date=int(time.time()) + 34 * one_day)
self.reservation_not_max_30 = Reservation(
start_date=int(time.time()) + 56 * one_day,
end_date=int(time.time()) + 82 * one_day)
self.reservation_gt_3_days = Reservation(
start_date=int(time.time()) + 5 * one_day,
end_date=int(time.time()) + 10 * one_day)
def make_reservations(jwt):
email = request.args.get('customer_email', type=str)
customer_id = db.session.query(Customer.id).filter(
Customer.email == email).one_or_none()
if customer_id is None:
abort(404)
rest_name = request.args.get('rest_name', type=str)
rest_id = db.session.query(Restaurant.id).filter(
Restaurant.name == rest_name).one_or_none()
if rest_id is None:
abort(404)
body = request.get_json()
if body is None:
abort(422)
time = body.get('time')
number = body.get('number')
if capacity_check(time, rest_id, number):
rsvn = Reservation()
rsvn.rest_id = rest_id
rsvn.customer_id = customer_id
rsvn.number = number
rsvn.time = time
rsvn.request = body.get('request', None)
rsvn.insert()
reservation_details = {
'customer': rsvn.customer.format(),
'restaurant': rsvn.rest.format(),
'reservation': rsvn.format()
}
return jsonify(
{
'success': True,
'reservation': reservation_details
}
)
else:
return jsonify({
'message': "This restaurant is fully booked. Check other times.",
'success': False
})
def app_fixtures():
u1 = User(username='******')
u2 = User(username='******')
u3 = User(username='******')
ecv.session.add(u1)
ecv.session.add(u2)
ecv.session.add(u3)
hours = 6
time_ready = datetime.datetime.utcnow() + datetime.timedelta(hours=hours)
o1 = Offer(host=u1,
portions=2,
price=3.50,
info="spaghetti gambanero, non-vegetarian",
time_ready=time_ready)
ecv.session.add(o1)
res1 = Reservation(user=u2, offer=o1, portions=1)
res2 = Reservation(user=u3, offer=o1, portions=1)
ecv.session.add(res1)
ecv.session.add(res2)
rat1 = Rating(
user=u2,
host=u1,
stars=2,
comment=
"I liked the sauce, but the company was terrible! I think his father was drunk..."
)
rat2 = Rating(user=u3,
host=u1,
stars=5,
comment="had a good time =) his dad is a fun guy")
ecv.session.add(rat1)
ecv.session.add(rat2)
# commit changes
ecv.session.commit()
def test_is_free(self): # change resources.is_free to reservations.is_free
customer = Customer(name='Teemu Teekkari',
email='teemu.teekkari@aalto fi')
resource = Resource(name="Resource1", resource_type="ROOM")
date = QtCore.QDate(2018, 3, 8)
start_time = QtCore.QTime(10, 0)
end_time = QtCore.QTime(11, 0)
start = QtCore.QDateTime(date, start_time)
end = QtCore.QDateTime(date, end_time)
reservation = Reservation(customer=customer,
resource=resource,
start=start,
end=end)
self.db.save(reservation)
self.assertEqual(
self.db.reservations.is_free(2, '2018-03-08 10:00',
'2018-03-08 11:00'), True)
self.assertEqual(
self.db.reservations.is_free(1, '2018-03-07 10:00',
'2018-03-07 11:00'), True)
self.assertEqual(
self.db.reservations.is_free(1, '2018-03-08 09:00',
'2018-03-08 09:59'), True)
self.assertEqual(
self.db.reservations.is_free(1, '2018-03-08 11:01',
'2018-03-08 12:00'), True)
self.assertEqual(
self.db.reservations.is_free(1, '2018-03-08 10:00',
'2018-03-08 11:00'), False)
self.assertEqual(
self.db.reservations.is_free(1, '2018-03-08 09:00',
'2018-03-08 11:00'), False)
self.assertEqual(
self.db.reservations.is_free(1, '2018-03-08 09:00',
'2018-03-08 10:30'), False)
self.assertEqual(
self.db.reservations.is_free(1, '2018-03-08 10:30',
'2018-03-08 12:00'), False)
self.assertEqual(
self.db.reservations.is_free(1, '2018-03-08 09:00',
'2018-03-08 14:00'), False)
self.assertEqual(
self.db.reservations.is_free(1, '2018-03-08 10:30',
'2018-03-08 10:59'), False)
self.assertEqual(
self.db.reservations.is_free(
reservation.resource.ID,
reservation.start.toString('yyyy-MM-dd hh:mm'),
reservation.end.toString('yyyy-MM-dd hh:mm'),
reservationID=reservation.ID), True)
def accept(self):
customer = self.customer_combo.currentData()
resource = self.resource_combo.currentData()
services = self.get_selected_services()
for service in services:
print(service)
start = self.start.dateTime()
end = self.end.dateTime()
if self.new_customer_button.isChecked():
name = self.name.text()
email = self.email.text()
if name and email:
customer = Customer(name=name, email=email)
else:
customer = None
if not customer:
self.error = MessageDialog('Please select a customer.')
self.error.show()
elif not resource:
self.error = MessageDialog('Please select a resource. Change starting time to find a free resource.')
self.error.show()
elif not services:
self.error = MessageDialog('Please select atleast one service.')
self.error.show()
else:
if self.reservation:
reservation = Reservation(ID=self.reservation.ID, customer=customer, services=services, resource=resource, start=start, end=end)
else:
reservation = Reservation(services=services, customer=customer, resource=resource, start=start, end=end)
if not self.database.save(reservation):
self.error = MessageDialog('Failed to create reservation')
self.error.show()
else:
self.information = MessageDialog("Resevation added", icon=QtWidgets.QMessageBox.Information)
self.information.show()
self.close()
self.parent.update()
def reservations(id=None):
if request.method == 'GET':
if id is not None:
reservation = Reservation.query.get(id)
if reservation:
return jsonify(reservation.serialize()), 200
else:
return jsonify({"reservation": "Not Found"})
else:
reservations = Reservation.query.all()
reservations = list(
map(lambda reservation: reservation.serialize(), reservations))
return jsonify(reservations), 200
if request.method == 'POST':
time = request.json.get('time')
date = request.json.get('date')
detail = request.json.get('detail')
total = request.json.get('total')
client_id = request.json.get('client_id')
worker_id = request.json.get('worker_id')
if not time:
return jsonify({"error": "time is required"}), 422
if not date:
return jsonify({"error": "date is required"}), 422
if not detail:
return jsonify({"error": "detail is required"}), 422
if not total:
return jsonify({"error": "total is required"}), 422
if not client_id:
return jsonify({"error": "client_id is required"}), 422
if not worker_id:
return jsonify({"error": "worker_id is required"}), 422
reservation = Reservation()
reservation.time = time
reservation.date = date
reservation.detail = detail
reservation.total = total
reservation.client_id = client_id
reservation.worker_id = worker_id
db.session.add(reservation)
db.session.commit()
return jsonify(reservation.serialize()), 201
if request.method == 'DELETE':
reservation = Reservation.query.get(id)
db.session.delete(reservation)
db.session.commit()
return jsonify({'reservation': 'Deleted'}), 200
def reserve_spot(request):
"""
View to handle booking a spot.
"""
# GET request will show a given spot.
if request.method == 'GET':
spot_id = request.GET.get("id")
if spot_id:
spot = Spot.objects.get(pk=spot_id)
else:
spot = None
return render(request, 'park/reserve.html', {
'spot': spot,
'id': spot_id
})
# POST request will reserve a given spot.
elif request.method == 'POST':
spot_id = request.POST.get("id")
# Check if spot exists.
if spot_id:
spot = Spot.objects.get(pk=spot_id)
if spot.available:
# If the spot is available make a reservation.
reservation = Reservation(
buyer=request.user,
seller=spot.owner,
spot=spot,
# Dummy price, needs to be set dynamically by GeoBucket
price=500,
# Dummy start, set to now needs to be set to user defined start time.
start=datetime.now())
reservation.save()
# Set spot to unavailable
spot.available = False
spot.in_use = True
spot.save()
# Find geohash to get grid value and retrieve geobucket.
spot_geohash = geohash_encode(spot.lat(), spot.lng())[:6]
geobucket, created = GeoBucket.objects.get_or_create(
geohash=spot_geohash)
# Add a search to the given geobucket and save.
geobucket.reservation()
geobucket.save()
return redirect('/park/reservations')
else:
return redirect('/')
def save_seat(cls, user_id, projection_id, row, col):
if UserController.check_id(user_id) is False:
raise UserError('There is no user with id = {}!'.format(user_id))
if ProjectionController.check_id(projection_id) is False:
raise ProjectionException(
'There is no projection with id = {}!'.format(projection_id))
if cls.check_if_seat_is_taken(projection_id, row, col):
raise SeatError('The seat is taken!')
session.add(
Reservation(user_id=user_id,
projection_id=projection_id,
row=row,
col=col))
def reservation_new():
reservation = Reservation()
if request.method == 'POST':
form = ReservationForm(request.form, obj=reservation)
if form.validate():
try:
form.populate_obj(reservation)
validate_reservation(reservation)
reservation.save()
flash('Yes, reserva cadastrado com sucesso.', 'success')
return redirect(url_for('reservations.reservation_index'))
except AttributeError as e:
flash(str(e), 'warning')
else:
form = ReservationForm(obj=reservation)
return render_template('reservations/new.html', form=form)
def test_list_reservation(self):
one_day = 60 * 60 * 24
start_date = int(time.time()) + 10 * one_day
end_date = int(time.time()) + 12 * one_day
reservation = Reservation(start_date=start_date, end_date=end_date)
reservation.reserve(self.user)
client = Client(enforce_csrf_checks="False")
response = client.get("/reservations/?start={start}&end={end}".format(
start=start_date - 10 * one_day, end=end_date + 20 * one_day))
print response
self.assertEqual(response.status_code, 200)
self.assertEqual(len(response.data), 2)
def add_res(id):
resource = db.session.query(Resource).get(id)
if resource is None:
raise NotFound("resource with id '{}' was not found.".format(id))
reservations = \
[res for res in resource.reservations if res.end_time > datetime.now()]
reservations.sort(key=lambda x: x.start_time)
if request.method == 'GET':
return render_template('form_res.html',
action="Add Reservation",
button="Save",
message="",
results=reservations)
data = request.form.to_dict(flat=True)
try:
data['start_time'], data['end_time'] = \
convert_str_to_time(data['date'], data['start'], data['duration'])
except Exception as e:
#print e.message
return render_template('form_res.html',
action="Add Reservation",
button="Save",
message="Time Input Invalid",
results=reservations)
message = valid_res(data['start_time'], data['end_time'], resource)
if message == "":
message = \
valid_user_time(data['start_time'], data['end_time'], current_user)
if message != "":
return render_template('form_res.html',
action="Add Reservation",
button="Save",
message=message,
results=reservations)
data['user_id'] = current_user.id
data['resource_id'] = id
data['resource_name'] = resource.name
resource.last_reserve_time = datetime.now()
reservation = Reservation()
reservation.deserialize(data)
db.session.add(reservation)
db.session.add(resource)
try:
db.session.commit()
except:
db.session.rollback()
return redirect(url_for('.list'))
def ticket_reservation(event_id) -> Response:
event_exists = db.session.query(Event).filter_by(id=event_id).count() > 0
if not event_exists:
raise EventNotFound()
ticket_type_id = db.session.query(TicketType.id).filter_by(
event_id=event_id).filter_by(name=request.json['ticket_type']).first()
if not ticket_type_id:
raise NoTicketTypeFound()
ticket = get_available_tickets(ticket_type_id[0]).first()
if not ticket:
raise NoTicketsAvailable()
reservation = Reservation(end_time=datetime.utcnow() +
timedelta(minutes=15),
ticket=ticket)
db.session.add(reservation)
db.session.commit()
return jsonify({'token': ticket.token})
def put(self):
body = request.get_json()
slot_id = body['slot_id']
user_id = body['user_id']
try:
reservation = Reservation()
reservation.slot_id = slot_id
reservation.user_id = user_id
db.session.add(reservation)
db.session.commit()
except:
db.session.rollback()
abort(422, "unprocessable")
return jsonify( { "success": True, "id": reservation.id } )
def test_get_start_and_end(self):
customer = Customer(name='Teemu Teekkari',
email='teemu.teekkari@aalto fi')
date = QtCore.QDate.currentDate()
resource = Resource(name="Resource1", resource_type="ROOM")
for x in range(8, 19):
start_time = QtCore.QTime(x, 0)
end_time = QtCore.QTime(x + 1, 0)
start = QtCore.QDateTime(date, start_time)
end = QtCore.QDateTime(date, end_time)
new_reservation = Reservation(customer=customer,
resource=resource,
start=start,
end=end)
self.db.save(new_reservation)
(first, last) = self.db.get_start_and_end(date)
self.assertEqual(first, 8)
self.assertEqual(last, 20)
