def new(request):
user = request.user
if request.method == 'POST':
print ("Post")
form = ReservationForm(request.POST)
if form.is_valid():
reservation=form.save(commit=False)
reservation.user=user
reservation.save()
#jump to payment processing
redirect_url = reverse('reservation_payment',kwargs={'reservation_id':reservation.id})
return HttpResponseRedirect(redirect_url)
else:
data = {
'user': user,
'form': form,
}
return render(request, 'reservations/new.html', data)
else:
reservation=Reservation()
reservation.user=user
form = ReservationForm(instance=reservation)
data = {
'user': user,
'form': form,
}
return render_to_response('reservations/new.html', data, context_instance=RequestContext(request))
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 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 new_reservation(request, beer_id):
beer = get_object_or_404(Beer, pk=beer_id)
if not request.user.has_perm('brewhouse.add_reservation'):
messages.warning(request, "You're not allowed to reserve beer.")
return redirect('beer-show', beer_id)
if not beer.is_reservable():
messages.warning(request, "That beer is not reservable!")
return redirect('beer-show', beer_id)
if Reservation.objects.filter(user=request.user, beer=beer):
# User has already reserved this beer!
messages.error(request, "You've already reserved a growler of this beer!")
return redirect('beer-show', beer_id)
if request.method == "POST" and request.POST.get('doit'):
r = Reservation()
r.beer = beer
r.user = request.user
r.save()
messages.success(request, "Your beer reservation request has been made and is pending approval.")
return redirect('beer-show', beer_id)
return render(request, 'brewhouse/new_reservation.html', locals())
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_tbl():
Person.create_table(fail_silently=True)
Company.create_table(fail_silently=True)
Payment.create_table(fail_silently=True)
Tariff.create_table(fail_silently=True)
Point.create_table(fail_silently=True)
Bike.create_table(fail_silently=True)
ReservationState.create_table(fail_silently=True)
Reservation.create_table(fail_silently=True)
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 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 search_reservations(_, info, **kwargs):
new_dict = kwargs
reservations = None
if ('user_id' in new_dict):
user_id = new_dict['user_id']
new_dict.pop('user_id')
reservations = Reservation.objects(user=user_id, **new_dict)
else:
reservations = Reservation.objects(**new_dict)
return reservations
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 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 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 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 reserve(email,roombc,datetime_start,datetime_end):
ret = {
'success': False,
'error': '',
}
if len(email) == 0 or len(roombc) == 0 or datetime_start is None or datetime_end is None:
ret['error'] = 'INTERNAL ERROR: reserve function was not given valid values.'
#print "ERROR: {%s} {%s} {%s} {%s}" % (email,roombc,datetime_start,datetime_end)
return ret
try:
user = Patron.objects.get(email=email)
except:
user = Patron()
user.email = email
user.date_last_booking = datetime.now() # mostly for daily quotas
try:
roomkey = RoomKey.objects.get(barcode=roombc)
room = roomkey.room
except:
ret['error'] = 'That room doesn\'t appear to exist. Please select another room.'
return ret
# don't 'try-except' this if it errors because that means a core problem exists
# that should be fixed.
user.save()
res = Reservation()
res.requested_user = user
res.room = room
res.datetime_start = datetime_start
res.datetime_end = datetime_end
# Allow early returns of keys and semi-correction of reservation end datetimes.
_ = return_key(roombc,False)
try:
res.clean() # not called automatically without a form
except ValidationError as ve:
# failure to clean, only validation errors are raised
if len(ve.messages) > 1:
for msg in ve.messages:
ret['error'] += msg + '<br />'
else:
ret['error'] = ve.messages[0]
return ret
# again, if an exception occurs by now, it's likely a bug.
res.save()
ret['success'] = True
return ret
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 get(self):
if users.get_current_user():
url = users.create_logout_url(self.request.uri)
url_linktext = 'Logout'
else:
url = users.create_login_url(self.request.uri)
url_linktext = 'Login'
self.redirect(users.create_login_url(self.request.uri))
user = users.get_current_user()
# update the numReservations and numsAvailable of this resource when delete the reservation
deleteReservationStr = self.request.get('deleteReservationID')
if deleteReservationStr != '':
deleteReservationKey = ndb.Key(urlsafe=deleteReservationStr)
thisReservation = deleteReservationKey.get()
thisResource = deleteReservationKey.parent().get()
thisResource.numReservations = thisResource.numReservations - thisReservation.numsOfAttendee
thisResource.numsAvailable = thisResource.maxReservations - thisResource.numReservations
thisResource.put()
deleteReservationKey.delete()
# sleep(0.2)
# The expired reservations will be deleted from data store before presenting
deleteExpiredReservationsKeys = Reservation.query(Reservation.endDateTime <= datetime.now()).fetch(keys_only=True)
for deleteReservationKey in deleteExpiredReservationsKeys:
thisReservation = deleteReservationKey.get()
resource = deleteReservationKey.parent().get()
resource.numReservations = resource.numReservations - thisReservation.numsOfAttendee
resource.numsAvailable = resource.maxReservations - resource.numReservations
resource.put()
ndb.delete_multi(deleteExpiredReservationsKeys)
#query reservations of the current user, order them based the reservation time('pubDate')
reservations = Reservation.query(user == Reservation.author).order(-Reservation.pubDate).fetch()
nowStr = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
now = datetime.strptime(nowStr, '%Y-%m-%d %H:%M:%S')
template_values = {
'reservations': reservations,
'user': user,
'url': url,
'url_linktext': url_linktext,
'now': now
}
template = JINJA_ENVIRONMENT.get_template('index.html')
self.response.write(template.render(template_values))
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 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 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_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 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 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(self):
resource_id = self.request.get('id')
resource = Resource.query(Resource.id == resource_id).get()
reservations = Reservation.query(
Reservation.resource_id == resource_id).fetch()
header = '<?xml version="1.0" encoding="UTF-8" ?>'
tag_owner = '<owner>{}</owner>'.format(resource.owner)
tag_name = '<name>{}</name>'.format(resource.name)
tag_start = '<start_time>{}</start_time>'.format(
resource.available_start_time)
tag_end = '<end_time>{}</end_time>'.format(resource.available_end_time)
tags_reservation = []
for r in reservations:
t = {}
t['user'] = '******'.format(r.user)
t['start'] = '<reservedAt>{}</reservedAt>'.format(r.start_time)
tags_reservation.append(t)
template_values = {
'header': header,
'owner': tag_owner,
'name': tag_name,
'start_time': tag_start,
'end_time': tag_end,
'reservations': tags_reservation,
}
template = JINJA_ENVIRONMENT.get_template('rss.html')
self.response.write(template.render(template_values))
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 get(self):
user = users.get_current_user()
if user:
url = users.create_logout_url(self.request.uri)
url_linktext = 'Logout'
# retrieve reservations by current user
now_time = datetime.now() - timedelta(minutes=300)
reservation_by_curr_user = Reservation.query(ndb.AND(Reservation.user == user.email(),
Reservation.end_time > now_time)) \
.fetch()
if reservation_by_curr_user:
reservation_by_curr_user = sorted(reservation_by_curr_user,
key=lambda r: r.start_time)
# retrieve all resources in system
sorted_resources = Resource.query().order(
-Resource.last_reservation_time)
# retrieve resources owned by current user
resources_owned = Resource.query(Resource.owner == user.email())
template_values = {
'user': user,
'reservation_by_curr_user': reservation_by_curr_user,
'sorted_resources': sorted_resources,
'resources_owned': resources_owned,
'url': url,
'url_linktext': url_linktext,
}
template = JINJA_ENVIRONMENT.get_template('index.html')
self.response.write(template.render(template_values))
else:
self.redirect(users.create_login_url(self.request.uri))
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 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 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 user_pay_reservation(_, info, id):
current_reservation = Reservation.objects(id=id).first()
vehicle = current_reservation.vehicle
vehicle.update(add_to_set__reservation=current_reservation)
current_reservation.update(set__status="paid")
vehicle.reload()
current_reservation.reload()
return current_reservation
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 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 get(self, request, uuid, format = None):
start = request.GET.get("start")
end = request.GET.get("end")
if start != None and end != None:
list_reservations = Reservation.get_reservation_range(start, end)
serialized_list = ReservationSerializer(list_reservations, many=True)
return Response(serialized_list.data, status=HTTP_200_OK)
elif uuid:
try:
reservation = Reservation.objects.get(uuid=uuid)
except ObjectDoesNotExist as E:
raise NoReservations()
serialized = ReservationSerializer(reservation)
return Response(serialized.data, status=HTTP_200_OK)
else:
serialized = ReservationSerializer(Reservation.get_next_n_day(), many=True)
if len(serialized.data) == 0:
raise NoReservations()
return Response(serialized.data, status=HTTP_200_OK)
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 edit(request, reservation_id=None):
Reservation.cancel_pending_reservations(user=request.user)
user = request.user
if reservation_id != None:
reservation=get_object_or_404(Reservation,pk=reservation_id)
if reservation.user !=user or reservation.is_cancelled():
return HttpResponseForbidden()
edit=True
else:
reservation=Reservation()
reservation.user=user
edit=False
form = ReservationForm(instance=reservation)
data = {
'user': user,
'form': form,
'edit': edit,
'reservation': reservation,
}
if request.method == 'POST':
form = ReservationForm(request.POST, instance=reservation)
print ("Post")
if form.is_valid():
reservation=form.save(commit=False)
reservation.save()
#jump to payment processing
redirect_url = reverse('reservation_payment',kwargs={'reservation_id':reservation.pk})
return HttpResponseRedirect(redirect_url)
else:
data['form']=form
return render(request, 'reservations/edit.html', data)
#else:
return render(request,'reservations/edit.html', data)
def run(self):
reservations = Reservation.get_where(
self._db, '*', "user_facing_status_key='complete'")
for r in reservations:
index_date = r.start_date
while (index_date < r.end_date):
year = index_date.year
month = index_date.month
index_date += timedelta(1)
self.__add(r.listing_id, year, month, 1)
self.save()
def post_reservation():
if not request.is_json:
abort(400, "The request payload is not in JSON format")
else:
try:
data = request.get_json()
if ("user_id" in data.keys() and "item_id" in data.keys()
and "rent_date" in data.keys()):
user = User.query.get_or_404(data["user_id"])
reservation = Reservation()
reservation.user_id = user.id
reservation.rent_date = data["rent_date"]
db.session.add(reservation)
db.session.commit()
reserve_item(data["item_id"], reservation.id)
return jsonify(reservation.serialize())
else:
abort(422)
except Exception as e:
return abort(e.code, e)
def create_reservation(jwt, restaurant_id):
restaurant = Restaurant.query.filter(
Restaurant.id == restaurant_id).one_or_none()
if restaurant is None:
abort(404)
body = request.get_json()
new_start_time = body.get('start_time', None)
new_end_time = body.get('end_time', None)
new_dinning_table_codes = body.get('dinning_table_codes', None)
new_dinning_tables = DinningTable.query.filter(
DinningTable.code.in_(new_dinning_table_codes)).all()
if len(new_dinning_tables) == 0:
abort(404)
try:
reservation = Reservation(start_time=new_start_time,
end_time=new_end_time)
for dinning_table in new_dinning_tables:
reservation.dinning_tables.append(dinning_table)
reservation.insert()
selection = Reservation.query.join(DinningTable, Reservation.dinning_tables) \
.filter(DinningTable.restaurant_id == restaurant_id) \
.order_by(Reservation.id).all()
current_reservations = paginate_reservations(request, selection)
return jsonify({
'success': True,
'created': reservation.id,
'reservations': current_reservations,
'total_reservations': len(selection)
})
except:
abort(422)
def ajax(request):
if request.method == "POST":
event = Reservation()
event.contact_first_name = request.POST["name"]
event.contact_last_name = request.POST["name"]
event.check_in_date = date.today()
event.save()
# Query the database for a list of ALL categories currently stored.
# Order the categories by no. likes in descending order.
# Retrieve the top 5 only - or all if less than 5.
# Place the list in our context_dict dictionary which will be passed to the template engine.
reservation_list = Reservation.objects.all()
reservation = list(Reservation.objects.all())
reservation_list = []
for r in reservation:
reservation_list.append({
"first_name": r.contact_first_name
})
# Render the response and send it back!
return HttpResponse(dumps(reservation_list, indent=4), content_type="application/json")
def cancel_pending_reservations(request):
cancelled = {"cancelled":Reservation.cancel_pending_reservations()}
return JsonResponse(cancelled)
def reservation_list(request):
Reservation.cancel_pending_reservations(user=request.user)
reservations= Reservation.objects.filter(user=request.user)
data = {'reservations': reservations}
return render(request, 'reservations/reservation_list.html', data)
def getreserveddates(request,month,year):
return JsonResponse(Reservation.get_ocuped_dates(month,year),safe=False)
def dom(request):
if request.method =="POST":
print request.POST
reservation = Reservation()
reservation.contact_first_name = request.POST["contact_first_name"]
reservation.contact_last_name = request.POST["contact_last_name"]
reservation.contact_email_address = request.POST["contact_email_address"]
reservation.contact_phone_number = request.POST["contact_phone_number"]
reservation.check_in_date = parser.parse(request.POST["check_in_date"])
reservation.check_out_date = parser.parse(request.POST["check_out_date"])
reservation.number_of_nights = int(request.POST["number_of_nights"])
reservation.number_of_adults = int(request.POST["number_of_adults"])
reservation.number_of_children = int(request.POST["number_of_children"])
reservation.message_to_hosts = request.POST["message_to_hosts"]
reservation.calculated_rate = float(request.POST["calculated_rate"])
reservation.cleaning_fee = float(request.POST["cleaning_fee"])
reservation.tax = float(request.POST["tax"])
reservation.payment_total = float(request.POST["payment_total"])
reservation.save()
return redirect("thank_you")
return render(request, 'dom.html')
def addBooking(request):
locale.setlocale(locale.LC_TIME, French_Locale)
print 'add booking'
if request.method == 'POST':
print 'method is POST {0}'.format(request.POST)
''' date has the following format Tuesday-16h00 '''
theDate = request.POST['date']
#print 'Date and Hour of the slot: {theDate}'.format(theDate=theDate)
week_number = request.POST['week']
year = request.POST['year']
song = urllib2.unquote(request.POST['song'])
studio_key = request.POST['studio']
''' date has the following format Tuesday-16h00 '''
date_start = computeSelectedDate(theDate, int(week_number), int(year))
startingHours = str(theDate).split('-')[1]
''' date has the following format Tuesday-16h00 '''
hours = int(str(startingHours).split('h')[0])
#print 'Starting Hours: {hours}'.format(hours=hours)
''' starting period h00, h15, h30, h45 '''
startingMinutes = int(str(request.POST['start'])[1:])
date_start += timedelta ( hours = hours, minutes = startingMinutes )
print date_start.strftime("%A %d-%B-%Y %H:%M:%S")
date_end = computeSelectedDate(theDate, int(week_number), int(year))
''' use duration to compute the end --- duration = 15 minutes '''
duration = request.POST['duration']
endingMinutes = 0
if (duration == '15 minutes') or (duration == '30 minutes') or (duration == '45 minutes'):
endingMinutes = startingMinutes + int(str(duration).split(' ')[0])
if (endingMinutes > 60):
hours = hours + 1
endingMinutes = endingMinutes - 60
elif (duration == '1 hour'):
hours = hours +1
endingMinutes = startingMinutes
else:
hours = hours
endingMinutes = startingMinutes
date_end += timedelta ( hours = hours , minutes = endingMinutes )
print date_end.strftime("%A %d-%B-%Y %H:%M:%S")
list_of_days = weekDays(datetime.today().year, int(week_number))
try:
reservation = Reservation (
made_by = request.user,
studio_key = Studio.objects.get(pk=studio_key),
made_when = datetime.now(),
date_start = date_start,
date_end = date_end,
song = song,
author = "")
''' record the new reservation '''
reservation.save()
except Exception as e:
print 'exception= {e}'.format(e=e)
users = serializers.serialize('json', list(User.objects.all()))
studios = serializers.serialize('json', list(Studio.objects.all()))
reservations = serializers.serialize('json', list(Reservation.objects.all().order_by("date_start")))
response_data = {
'current_user_id': request.user.id,
'week_number': week_number,
'list_of_days': list_of_days,
'users': users,
'studios': studios,
'reservations': reservations,
}
''' need to encode french months like février '''
return HttpResponse(json.dumps(response_data, ensure_ascii=False, encoding="latin-1"), content_type="application/json")
def get_reserved_dates(request, reservation_id):
occuped={"used":Reservation.get_ocuped_dates(int(reservation_id))}
return JsonResponse(occuped)
