def getReservation(self, sessionId, reservationId):
self.__db = Database()
self.__sessionId = sessionId
if self.__db.connect():
#check session id and get user id
auth = AuthenticationManager()
if auth.isSessionIdCorrect(self.__sessionId):
self.__userId = auth.getUser().getUserId()
sql = 'SELECT `username`, `status` FROM `user` WHERE `user_id` = "'+str(self.__userId)+'";'
self.__db.execute(sql)
u = self.__db.getCursor().fetchone()
username = u[0]
status = u[1]
if str(status).lower() == 'admin':
sql = 'SELECT `reservation_id`, `title`, `description`, `start`, `end`, `image_type`, `type` FROM `reservation` WHERE `reservation_id`="'+str(reservationId)+'";'
self.__db.execute(sql)
data = self.__db.getCursor().fetchone()
r = Reservation(data)
r.setOwner(username)
r.setReservationsSite()
status = r.getReservationsSite()[0].getStatus()
return r
return None
def add_reservation(self, username, projection_id, row, col):
session.add(
Reservation(username=username,
projection_id=projection_id,
row=row,
col=col))
session.commit()
def make_reservation():
customer = ask_name()
destination = select_destination()
print(f"Your randomly selected destination is: {destination.city}")
while True:
try:
vehicle = select_vehicle()
print(f"You've selected a {vehicle.vtype}")
if vehicle.vtype == 'bicycle':
vehicle.cycle()
elif vehicle.vtype == 'car':
vehicle.drive()
elif vehicle.vtype == 'boat':
vehicle.sail()
elif vehicle.vtype == 'hovercraft':
vehicle.drive()
vehicle.sail()
elif vehicle.vtype == 'train':
vehicle.ride()
elif vehicle.vtype == 'airplane':
vehicle.fly()
except:
print("Please try again")
else:
break
price = vehicle.km_cost * destination.distance
reservation = Reservation(customer.name, destination.city,
destination.distance, vehicle.vtype, price)
write_to_file(reservation)
pickle_to_file(reservation)
return reservation
def generateReservation(collectionId, idSpectateur, idGame, date, heure,
email):
reservation = Reservation(collectionId, idSpectateur, idGame,
date + ' ' + heure, email)
reservation.toString()
newReservation_id = addReservationToSQL(reservation)
return newReservation_id
def getReservations(self, sessionId = None, userId = None, ended = None):
if sessionId == None and userId == None:
return None
self.__db = Database()
self.__sessionId = sessionId
self.__reservations = []
if self.__db.connect():
try:
if userId == None:
#check session id and get user id
auth = AuthenticationManager()
if auth.isSessionIdCorrect(self.__sessionId):
self.__userId = auth.getUser().getUserId()
else:
self.__userId = userId
if self.__userId != None:
sql = 'SELECT `username` FROM `user` WHERE `user_id`="'+str(self.__userId)+'";'
self.__db.execute(sql)
username = self.__db.getCursor().fetchone()[0]
self.__db.lock({'reservation':'READ'})
sql = 'SELECT `reservation_id`, `title`, `description`, `start`, `end`, `image_type`, `type` FROM `reservation` WHERE `user_id`="'+str(self.__userId)+'";'
self.__db.execute(sql)
data = self.__db.getCursor().fetchall()
currentTime = NOW
for d in data:
end = d[4]
diff = currentTime - end
r = Reservation(d)
r.setOwner(username)
r.setReservationsSite()
status = r.getReservationsSite()[0].getStatus()
if ended == None:
#for pcc
self.__reservations.append(r)
elif ended:
#history (already ended)
if diff >= timedelta(hours=0) or status == 'cancel':
self.__reservations.append(r)
else:
#see reservations which havn't ended
if diff < timedelta(hours=0) and status != 'cancel':
self.__reservations.append(r)
self.__db.unlock()
finally:
self.__db.close()
return self.__reservations
def test_take_reservationC(self):
name = "Carla's"
genre = "Diner"
max_seats = 5
open_t = 6
close_t = 15
restaurant = Restaurant(name, genre, max_seats, open_t, close_t)
customer = Customer("George", "(802)555-5555")
res1 = Reservation(customer, 12, 2)
res2 = Reservation(customer, 12, 3)
restaurant.take_reservation(res1)
restaurant.take_reservation(res2)
self.assertEqual(restaurant.seats_available, 0)
def read_reservations():
r = open('reservations.txt', 'r+')
reservations = []
for rline in r.readlines():
rparts = rline.strip().split(',')
reserved_room = Reservation(int(rparts[0]),
datetime.strptime(rparts[1], '%d.%m.%Y'),
rparts[2])
reservations.append(reserved_room)
r.close()
return reservations
def getRoomReservations(self):
self.conn.execute_query('SELECT * FROM Edu_RoomReservations')
reservations = {}
for row in self.conn:
reservation = Reservation(row['RoomID'], row['DayID'],
row['StartID'], row['EndID'])
reservations[row['RoomID']] = []
reservations[row['RoomID']].append(reservation)
self._reservations = reservations
return reservations
def createReservation(self, roomType, familyName, guestsNumber, arrival,
departure):
'''
Validates and creates a reservation.
'''
reservation = Reservation(None, None, familyName, guestsNumber,
arrival, departure)
self._validateReservation(roomType, reservation)
return self._repository.createReservation(roomType, reservation)
def add(self,
table,
date,
time,
customer_id,
num_people,
petitions,
type,
ID=None):
super().add(
Reservation(table, date, time, customer_id, num_people, petitions,
type, ID))
def make_reservation(self, name, number_of_tickets):
self.show_movies()
choosen_movie_id = input("Choose a movie>")
self.show_movie_projections(choosen_movie_id)
choosen_projection_id = input("Choose a projection>")
free_slots_for_choosen_projection = self.free_slots_for_projection(
choosen_projection_id)
if free_slots_for_choosen_projection < number_of_tickets:
print("Not enought tickets for this projection, only {} available".
format(free_slots_for_choosen_projection))
return
print("Available seats (marked with a dot):")
reset_hall()
self.fill_hall_for_projection(choosen_projection_id)
pprint(hall)
checked_tickets = 0
seats = []
while checked_tickets != number_of_tickets:
seat_row = int(
input("Choose seat{}(row)>".format(checked_tickets + 1)))
seat_col = int(
input("Choose seat{}(col)>".format(checked_tickets + 1)))
if self.is_position_free([seat_row, seat_col]):
seats.append([seat_row, seat_col])
checked_tickets += 1
else:
print("This seat is already taken! or it's outside the hall!")
choosen_movie_name = session.query(
Movie.name).filter(Movie.id == choosen_movie_id).one()
choosen_movie_date = session.query(
Projection.date).filter(Projection.id == choosen_movie_id).one()
choosen_movie_time = session.query(
Projection.time).filter(Projection.id == choosen_movie_id).one()
choosen_projection_type = session.query(Projection.type).filter(
Projection.id == choosen_projection_id).one()
print("This is your reservation:")
print("Movie: ", choosen_movie_name)
print("Date and Time: {}:{} - ({})".format(choosen_movie_date,
choosen_movie_time,
choosen_projection_type))
print("Seats: ", )
for seat in seats:
print("row:{}, col:{}".format(seat[0], seat[1]), )
is_finalized = input("Confirm - type 'finalize'>")
if is_finalized == 'finalize':
for seat in seats:
session.add(
Reservation(username=name,
projection_id=choosen_projection_id,
row=seat[0],
col=seat[1]))
session.commit()
def loadGuestsDict():
guests = json.loads(open('./Guests.json').read())
currentGuests = {}
for guest in guests:
currentRes = Reservation(guest['reservation']['roomNumber'], \
guest['reservation']['startTimestamp'], \
guest['reservation']['endTimestamp'])
newGuest = Guest(guest['id'], \
guest['firstName'], \
guest['lastName'], \
currentRes)
currentGuests.update({newGuest.id: newGuest})
return currentGuests
def test_has_seatsA(self):
name = "Carla's"
genre = "Diner"
max_seats = 5
open_t = 6
close_t = 15
restaurant = Restaurant(name, genre, max_seats, open_t, close_t)
customer = Customer("George", "(802)555-5555")
res1 = Reservation(customer, 12, 2)
restaurant.take_reservation(res1)
self.assertEqual(restaurant.has_seats(3), True)
def _loadReservations(self, fileName):
'''
Loads from '<fileName>' the reservations
'''
with open(fileName, "r") as file:
data = file.read().strip("\n").split("\n")
reservations = {}
for current in data:
parameters = current.split(",")
ID = parameters[0].strip(" ")
roomNumber = int(parameters[1].strip(" "))
familyName = parameters[2].strip(" ")
guestsNumber = int(parameters[3].strip(" "))
arrival = datetime.datetime.strptime(parameters[4].strip(" ") + ".2018", "%d.%m.%Y")
departure = datetime.datetime.strptime(parameters[5].strip(" ") + ".2018", "%d.%m.%Y")
reservations[ID] = Reservation(ID, roomNumber, familyName, guestsNumber, arrival, departure)
return reservations
def availableRooms(self, arrival, departure):
'''
Returns a list of the available rooms for the given interval.
'''
matching = []
matching.extend(self._rooms[1])
matching.extend(self._rooms[2])
matching.extend(self._rooms[4])
supposed = Reservation(None, None, None, None, arrival, departure)
for reservation in self._reservations.values():
if reservation.roomNumber in matching:
if self._datesOverlap(reservation, supposed):
matching.remove(reservation.roomNumber)
if matching == []:
raise RepoError("No available rooms of this type.")
matching.sort()
return matching
def monthlyReport(self):
'''
Returns a list of the months sorted in descending order by the number of the reservation days.
'''
monthDays = []
for month in range(1,13):
monthDays.append([month, 0])
start = datetime.datetime (year = 2018, month = month, day = 1)
end = datetime.datetime(year = 2018, month = month, day = monthrange(2018, month)[1])
supposed = Reservation(None, None, None, None, start, end)
for reservation in self._reservations.values():
if self._datesOverlap(reservation, supposed):
relativeStart = reservation.arrival
relativeEnd = reservation.departure
if relativeStart < start:
relativeStart = start
if relativeEnd > end:
relativeEnd = end
monthDays[month-1][1] += (relativeEnd-relativeStart).days
monthDays.sort(key= lambda element: element[1], reverse=True)
results = []
for element in monthDays:
results.append( str(month_name[element[0]]) + ": " + str(element[1]) )
return results
def reserve(self, patron_id):
self.reservation = Reservation(patron_id, self.qr_code)
def removeSliceFromResourceTable(s1):
if s1 != 0:
reser = Reservation(s1, 0)
reser.deleteSlice()
else:
print('undefined number of parameters')
from datetime import date, time
from Reservation import Location, Reservation
reservation = Reservation({
'location': Location.HL15,
'username': '',
'password': ''
})
reservation.book(date(2019, 8, 21), 5, time(hour=14, minute=30), time(hour=2))
def register_event(self, event):
event_id = ReservationManager.generate_uuid()
self.reservation_map[event_id] = Reservation(event)
return event_id
"The room is already reserved at that day. Try another date (DD.MM.YYYY): "
)
else:
break
except:
reserve_date = input(
"Please enter valid date format (DD.MM.YYYY): ")
reserve_guest = input("What is the guest's name: ")
while True:
if reserve_guest == "" or len(reserve_guest) < 2:
reserve_date = input("Please type a valid name: ")
else:
reservations.append(
Reservation(
reserve_room_number,
datetime.strptime(reserve_date, '%d.%m.%Y'),
reserve_guest))
write_reservations(reservations)
print('Room reserved successfully\n\n')
break
#show unoccupied rooms
elif val == "3":
unocc_date = input("Which date would you like to see? : ")
while True:
try:
unocc_date = datetime.strptime(unocc_date, '%d.%m.%Y')
for room in rooms:
reserved = False
for reservation in reservations:
def initial_VR2(rtV, Q, rtV2, Q2):
print(
'filtering feasiblity of user demands, removes if not feasible...\n'
)
#initial virtual resource allocation of the slice in the base stations
_, un = Reservation.getUnusedResourceAndNumOfSlices()
[K, B] = np.array(rtV).shape
[K2, B2] = np.array(rtV2).shape
qyu = np.zeros((K, B))
for i in range(0, K):
for j in range(0, B):
qyu[i, j] = Q[0, i] / rtV[
i,
j] # how much fractions is required by the users in each bs assuming single user base station associations
qyu2 = np.zeros((K2, B2))
for i in range(0, K2):
for j in range(0, B2):
qyu2[i, j] = Q2[0, i] / rtV2[
i,
j] # how much fractions is required by the users in each bs assuming single user base station associations
#calculate the resource requitement of the slice in the BSs assumig every user is admitted sequencially as they come to the nearest BS
VR = np.zeros((1, B))
VR2 = np.zeros((1, B2))
accepF = np.zeros((1, K)) #how much percent of the user is accepted
copyr = rtV
accepF2 = np.zeros((1, K2)) #how much percent of the user is accepted
copyr2 = rtV2
wh = 0
while wh <= K * B + K2 * B2:
maxr1 = copyr.max() # the smallest user bs distance combination
maxr2 = copyr2.max(
) # the smallest user bs distance combination for i=1:1:K
if maxr1 > maxr2:
maxr = maxr1
for i in range(0, K):
for m in range(0, B):
if copyr[i, m] == maxr and (
accepF[0, i] + 1
) != 2: # plus one is used to ignore very small fraction
if un[0,
m] >= qyu[i, m] * (1 - accepF[0, i]) and qyu[
i, m] > 0 and un[0, m] > 0:
VR[0,
m] = VR[0,
m] + qyu[i, m] * (1 - accepF[0, i])
un[0,
m] = un[0,
m] - qyu[i, m] * (1 - accepF[0, i])
accepF[0, i] = 1
elif un[0, m] < qyu[i, m] * (1 - accepF[
0, i]) and qyu[i, m] > 0 and un[0, m] > 0:
VR[0, m] = VR[0, m] + un[0, m]
un[0, m] = 0
accepF[0, i] = accepF[
0, i] + un[0, m] / (qyu[i, m] *
(1 - accepF[0, i]))
copyr[i, m] = 0
else:
maxr = maxr2
for i in range(0, K2):
for m in range(0, B2):
if copyr2[i, m] == maxr and (
accepF2[0, i] + 1
) != 2: # plus one is used to ignore very small fraction
if un[0, m] >= qyu2[i, m] * (1 - accepF2[
0, i]) and qyu2[i, m] > 0 and un[0, m] > 0:
VR2[0, m] = VR2[
0, m] + qyu2[i, m] * (1 - accepF2[0, i])
un[0,
m] = un[0, m] - qyu2[i, m] * (1 -
accepF2[0, i])
accepF2[0, i] = 1
elif un[0, m] < qyu2[i, m] * (1 - accepF2[
0, i]) and qyu2[i, m] > 0 and un[0, m] > 0:
VR2[0, m] = VR2[0, m] + un[0, m]
un[0, m] = 0
accepF2[0, i] = accepF2[
0, i] + un[0, m] / (qyu2[i, m] *
(1 - accepF2[0, i]))
copyr2[i, m] = 0
if (copyr.max() == 0
and copyr2.max() == 0) or (accepF.min() == 1
and accepF2.min() == 1):
break
wh = wh + 1
accept = np.floor(accepF)
accept2 = np.floor(accepF2)
if np.sum(
accept
) >= 1: # check if there is at leasst one user fully accepted
S, _ = Reservation.getUnusedResourceAndNumOfSlices()
res = S + 1
V = VR
RQ = np.zeros((1, B))
Reservation(res, np.zeros((1, B)), RQ).initialization()
else:
res = 0 # reject the slice. no enouph resource
V = np.zeros((1, B))
if np.sum(
accept2
) >= 1: # check if there is at leasst one user fully accepted
S, _ = Reservation.getUnusedResourceAndNumOfSlices()
res2 = S + 1
V2 = VR2
RQ2 = np.zeros((1, B))
Reservation(res2, np.zeros((1, B)), RQ2).initialization()
else:
res2 = 0 # reject the slice. no enouph resource
V2 = np.zeros((1, B))
return res, V, accept, res2, V2, accept2
def make_reservation(self, restaurant, time, party_size):
res = Reservation(self, time, party_size)
restaurant.take_reservation(res)
return res
