class Users:
def __init__(self):
self.allUsers = Table("hsep", 10, "bst") # datastructure
self.totalUsers = 0
def addUser(self, firstName, lastName, mail, userID):
newUser = SingleUser(userID, firstName, lastName, mail)
insertSucces = self.allUsers.insert((userID, newUser))
if insertSucces:
self.totalUsers += 1
return insertSucces
def getUserInfo(self, userID):
userExists, userData = self.allUsers.retrieve(userID)
return userData.firstName, userData.lastName, userData.mail
def changeUserMail(self, userID, newMail):
userExists, userInfo = self.allUsers.retrieve(userID)
if userExists:
userInfo[1].mail = newMail
return True
return False
def getUsers(self):
return self.allUsers.traverse()
class Movies:
def __init__(self):
self.allFilms = Table("bst") #datastructure
self.totalFilms = 0
def addMovie(self, movie, rating=0.7, movieID=0):
if type(movie) != SingleMovie:
movie = SingleMovie(movie, rating, movieID)
rv = self.allFilms.insert((movie.movieID, movie))
if rv is True:
self.totalFilms += 1
return rv
def deleteMovie(self, movieID):
rv = self.allFilms.delete(movieID)
if rv is True:
self.totalFilms -= 1
return rv
def getMovies(self):
return self.allFilms.traverse()
def changeRating(self, movieID, newRating):
if self.allFilms.retrieve(movieID)[0] is False:
return False
film = self.allFilms.retrieve(movieID)[1]
film.rating = newRating
return True
def getMovieTitle(self, movieID):
return self.allFilms.retrieve(movieID)[1].title
class Rooms:
def __init__(self):
self.allRooms = Table("hsep", 10, "dll") # datastructure
self.totalRooms = 0
def addRoom(self, room, seats=100):
if type(room) != SingleRoom:
room = SingleRoom(room, seats)
roomName = room.roomName
rv = self.allRooms.insert((roomName, room))
if rv is True:
self.totalRooms += 1
return rv
def deleteRoom(self, roomName):
rv = self.allRooms.delete(roomName)
if rv is True:
self.totalRooms -= 1
return rv
def retrieveRoom(self, roomName):
return self.allRooms.retrieve(roomName)[1]
def showRooms(self):
return self.allRooms.traverse()
def showReservations(self, roomName):
room = self.allRooms.retrieve(roomName)[1]
return room.showReservations()
def reserveRoom(self, roomName, timeSlot, date):
room = self.allRooms.retrieve(roomName)[1]
return room.reserve(timeSlot, date)
def cancelReservation(self, roomName, timeSlot, date):
room = self.allRooms.retrieve(roomName)[1]
return room.cancel(timeSlot, date)
def showEmptySeats(self, roomName, timeSlot, date):
room = self.allRooms.retrieve(roomName)[1]
return room.showEmptySeats(timeSlot, date)
def isFree(self, roomName, timeSlot, date):
room = self.allRooms.retrieve(roomName)[1]
return room.isFree(timeSlot, date)
def changeEmptySeats(self, roomName, timeSlot, date, seats):
if self.allRooms.retrieve(roomName) is False:
return False
room = self.allRooms.retrieve(roomName)[1]
return room.changeSeats(seats, timeSlot, date)
class Slots:
def __init__(self):
self.allSlots = Table("23")
def addSlot(self, time, slotID):
return self.allSlots.insert((slotID, time))
def setupDefaultSlots(self):
self.addSlot("14:30", 1)
self.addSlot("17:00", 2)
self.addSlot("20:00", 3)
self.addSlot("22:30", 4)
def slotIDToTime(self, slotID):
return self.allSlots.retrieve(slotID)[1]
def listAllSlots(self):
returnList = []
idList = self.allSlots.traverse()
for slot in idList:
returnList.append(self.slotIDToTime(slot))
return returnList
class Plays:
def __init__(self, allRooms, allMovies):
self.allPlays = Table("ll")
self.allRooms = allRooms
self.allMovies = allMovies
def getAllPlays(self):
self.allPlays.table.bubbleSort("Play") # sort for linked lists
return self.allPlays.traverse()
def addPlay(self, roomName, timeSlot, date, movieID, playID):
toegevoegd = False
if self.allRooms.isFree(roomName, timeSlot, date):
self.allRooms.reserveRoom(roomName, timeSlot, date)
newPlay = SinglePlay(roomName, timeSlot, date, movieID, playID)
self.allPlays.insert((playID, newPlay))
toegevoegd = True
return toegevoegd
def removePlay(self, playID):
playExists, playData = self.allPlays.retrieve(playID)
if playExists:
self.allRooms.cancelReservation(playData.roomName, playData.timeSlot, playData.date)
return self.allPlays.delete(playID)
return playExists
def getInfo(self, playID):
playExists, playData = self.allPlays.retrieve(playID)
return playData.roomName, playData.timeSlot, playData.date, playData.movieID
def changeRoomName(self, playID, newRoomName):
veranderd = False
playExists, playData = self.allPlays.retrieve(playID)
if playExists:
if self.allRooms.isFree(newRoomName, playData.timeSlot, playData.date):
playData.roomName = newRoomName
veranderd = True
return veranderd
return playExists
def changeTime(self, playID, newTimeSlot):
veranderd = False
playExists, playData = self.allPlays.retrieve(playID)
if playExists:
if self.allRooms.isFree(playData.roomName, newTimeSlot, playData.date):
playData.timeSlot = newTimeSlot
veranderd = True
return veranderd
return playExists
def changeDate(self, playID, newDate):
veranderd = False
playExists, playData = self.allPlays.retrieve(playID)
if playExists:
if self.allRooms.isFree(playData.roomName, playData.timeSlot, newDate):
playData.date = newDate
veranderd = True
return veranderd
return playExists
def changeMovie(self, playID, newMovieID):
playExists, playData = self.allPlays.retrieve(playID)
if playExists:
playData.movieID = newMovieID
return playExists
class SingleRoom:
def __init__(self, roomName, seats):
self.roomName = roomName
self.seats = seats
self.allReservations = Table("23") # datastructure
def reserve(self, timeSlot, date):
# time: 00:00
# date: dd/mm/jjjj
usedSeats = Table("stack")
entered = Table("stack")
return self.allReservations.insert(
(date + " " + str(timeSlot), (usedSeats, entered)))
def cancel(self, timeSlot, date):
return self.allReservations.delete(date + " " + str(timeSlot))
def showReservations(self):
return self.allReservations.traverse()
def showEmptySeats(self, timeSlot, date):
usedSeats = self.allReservations.retrieve(date + " " +
str(timeSlot))[1]
if usedSeats is None:
return self.seats
return self.seats - usedSeats[0].table.size
def isFree(self, timeSlot, date):
return not self.allReservations.retrieve(date + " " + str(timeSlot))[0]
def changeSeats(self, seats, timeSlot, date):
# Positive seats decreases emptySeats
# Negative seats increases emptySeats
usedSeats = self.allReservations.retrieve(date + " " + str(timeSlot))
if usedSeats[1] is None:
return False
else:
usedSeats = usedSeats[1][0]
if seats < 0:
if abs(seats) <= usedSeats.table.size:
for _ in range(abs(seats)):
usedSeats.table.pop()
return True
return False
elif seats > 0:
if seats + usedSeats.table.size <= self.seats:
for _ in range(seats):
usedSeats.table.push("X")
return True
return False
def enterRoom(self, timeSlot, date, peopleAmount):
self.changeSeats((-1) * peopleAmount, timeSlot, date)
entered = self.allReservations.retrieve(date + " " + str(timeSlot))[1]
if entered is not None:
entered = entered[1]
for _ in range(peopleAmount):
entered.table.push("X")
def entered(self, timeSlot, date):
entered = self.allReservations.retrieve(date + " " + str(timeSlot))[1]
if entered is not None:
return entered[1].table.size
return 0