def testRentalRepository():
rentalRepo = Repository()
book1 = Book(0, "The Q", "Albert", "Heinrich")
book2 = Book(1, "The D", "Elbert", "Reinsich")
client1 = Client(0, "Mihai", 1854987548795)
client2 = Client(1, "Alex", 1987548759658)
rentalRepo.addElement(Rental(1, book1, 0))
rentalRepo.addElement(Rental(0, book2, 1))
# _find(_id) returns the Rental from the repository
# that has the client Id equal to _id
assert rentalRepo._find(0).getRentedBook() == book1
assert rentalRepo._find(1).getId() == 1
assert rentalRepo._find(1).getRentedBook() == book2
assert rentalRepo._find(0).getId() == 0
# findId() function for Repository class
assert rentalRepo.findId(12) == False
assert rentalRepo.findId(0) == True
# elementFromId()
assert rentalRepo.elementFromId(0).getRentedBook() == book1
rentalRepo.addElement(Rental(1, book2, 2))
print ("Rental repository tests ran successfully!")
def testRentalRepository(self):
rentalRepo = Repository()
book1 = Book(0, "The Q", "Albert", "Heinrich")
book2 = Book(1, "The D", "Elbert", "Reinsich")
client1 = Client(0, "Mihai", 1854987548795)
client2 = Client(1, "Alex", 1987548759658)
rentalRepo.addElement(Rental(1, book1, 0))
rentalRepo.addElement(Rental(0, book2, 1))
# _find(_id) returns the Rental from the repository
# that has the client Id equal to _id
self.assertEqual(rentalRepo._find(0).getRentedBook(), book1)
self.assertEqual(rentalRepo._find(1).getId(), 1)
self.assertEqual(rentalRepo._find(1).getRentedBook(), book2)
self.assertEqual(rentalRepo._find(0).getId(), 0)
# findId() function for Repository class
self.assertEqual(rentalRepo.findId(12), False)
self.assertEqual(rentalRepo.findId(0), True)
# elementFromId()
self.assertEqual(rentalRepo.elementFromId(0).getRentedBook(), book1)
rentalRepo.addElement(Rental(1, book2, 2))
def setUp(self):
self.client = Client(23, 'alex')
self.client2 = Client(12, 'diana')
self.book = Book(21, 'titlu', 'descriere', 'author')
self.book2 = Book(22, 'titlu2', 'descriere2', 'author2')
self.rental = Rental(21236, 21, 23, date(2017, 11, 5), date(2017, 12, 6), date(2017, 12, 5))
self.rental2 = Rental(21236, 21, 23, date(2017, 11, 5), date(2017, 12, 6), date(2017, 12, 5))
def testRental(self):
repo = Repository()
book1 = Book(1, "ala", "mala", "dala")
rentList = Repository()
rentList.addElement(Rental(2, book1, 0))
lis1 = rentList.getElementList()
self.assertEqual(len(lis1), 1)
rentList.addElement(Rental(2, book1, 1))
lis1 = rentList.getElementList()
self.assertEqual(len(lis1), 2)
self.assertEqual(lis1[0].getRenterId(), 2)
self.assertEqual(lis1[0].getRentedBook(), book1)
self.assertEqual(lis1[0].getId(), 0)
def __loadFromFile(self, type):
"""
:param sample: Element
:return: None
:raises RepositoryException when the file cannot be read for some reason
"""
try:
f = open(self.__fileName, "r")
line = f.readline().strip()
while line != "":
attrs = line.split(",")
if type == Book:
book = Book(int(attrs[0]), attrs[1], attrs[2], attrs[3])
self.__repo.add(book)
line = f.readline().strip()
if type == Client:
client = Client(int(attrs[0]), attrs[1])
self.__repo.add(client)
line = f.readline().strip()
if type == Rental:
rental = Rental(
int(attrs[0]), int(attrs[1]), int(attrs[2]),
createDateFromString(self.__reverseDate(attrs[3])),
createDateFromString(self.__reverseDate(attrs[4])),
createDateFromString(self.__reverseDate(attrs[5])))
self.__repo.add(rental)
line = f.readline().strip()
except IOError:
raise RepositoryException()
finally:
f.close()
def cancel(rentalId):
# Authenticate
authenticator = Authenticator(request.headers.get(
HeaderKey.TOKEN)).allowAgent()
authentification = authenticator.authenticate()
if FieldKey.ERROR in authentification:
return ResponseFormatter.getFormattedValidatorResponse(
authentification)
# Create Domain Instance
rental = Rental()
rental.id = rentalId
rental.status = RentalStatus.CANCELLED
# Call Service Layer
response = RentalService.update(rental)
return ResponseFormatter.getFormmattedServiceResponse(
RentalConverter.toResource, response)
def testRental():
repo = Repository()
book1 = Book(1, "ala", "mala", "dala")
rentList = Repository()
rentList.addElement(Rental(2, book1, 0))
lis1 = rentList.getElementList()
assert len(lis1) == 1
rentList.addElement(Rental(2, book1, 1))
lis1 = rentList.getElementList()
assert len(lis1) == 2
assert lis1[0].getRenterId() == 2
assert lis1[0].getRentedBook() == book1
assert lis1[0].getId() == 0
print ("Rental tests ran successfully!")
def read_rental():
bookID = UI.readInt("enter book ID: ")
clientID = UI.readInt("enter client ID: ")
rentalID = int(str(bookID) + str(clientID) + str(randint(0, 9)))
rentedDate = UI.readDate()
dueDate = date(2017, rentedDate.month % 12 + 1, randint(1, 31))
returnedDate = None
return Rental(rentalID, bookID, clientID, rentedDate, dueDate,
returnedDate)
def validateUpdate(rental):
errors = []
if PersistenceValidator.checkExists(Rental, rental.id):
original = ReadOnlyAccess.getEntityCopy(Rental, rental.id)
else:
original = Rental()
errors.append(
PersistenceValidator.entityDoesNotExist(
"Rental", "id", rental.id))
return BaseValidator.getValidationMessage(
RentalValidator.checkUniqueness(errors, rental, original))
def createRental(self, rentalId, client, car, start, end, recordUndo=True):
rental = Rental(rentalId, start, end, client, car)
self.__validator.validate(rental)
'''
Check the car's availability for the given period
'''
if self.isCarAvailable(rental.car, rental.start, rental.end) == False:
raise CarRentalException("Car is not available during that time!")
self.__repository.store(rental)
return rental
def addRentalUI(self):
rentalID = int(input("RentalID: "))
bookID = int(input("BookID: "))
clientID = int(input("ClientID: "))
rd = input("Rented date: ")
rd = datetime.strptime(rd, '%Y-%m-%d')
dd = input("Due date: ")
dd = datetime.strptime(dd, '%Y-%m-%d')
retd = None
r = Rental(rentalID, bookID, clientID, rd, dd, retd)
self._controller.createRental(rentalID,bookID,clientID,rd,dd,retd)
def _loadFile(self):
f = open(self._fileName, "r")
line = f.readline().strip()
while len(line) > 2:
tok = line.split(";")
d1 = tok[3].split("-")
d2 = tok[4].split("-")
d3 = tok[5].split("-")
rental = Rental(int(tok[0]), int(tok[1]), int(tok[2]), date(int(d1[0]), int(d1[1]), int(d1[2])),
date(int(d2[0]), int(d2[1]), int(d2[2])), date(int(d3[0]), int(d3[1]), int(d3[2])))
Repository.store(self, rental)
line = f.readline().strip()
def init_rental():
startDay = 1
returnDay = 2
indexRent = 1
for index, car in enumerate(carRepo.getAll()):
rentalRepo.store(
Rental(indexRent, date(2016, 11, startDay),
date(2016, 11, returnDay),
clientRepo.getAll()[index], car))
indexRent += 1
startDay += 1
returnDay += 2
def both_add_rental(self, BID, CID, input_day, input_month):
try:
self.__Ucontroller.newOperation()
self.__Rcontroller.addRental(
Rental.create_rental(int(BID.get()), int(CID.get()),
int(input_day.get()),
int(input_month.get())))
messagebox.showinfo(
"INFO", "RENTAL ADDED\n" + str(
Rental.create_rental(int(BID.get()), int(CID.get()),
int(input_day.get()),
int(input_month.get()))))
except Exception as exc:
print(str(exc))
window = Toplevel(self.master)
window.pack_propagate(0)
v = StringVar()
v.set(str(exc))
label = Label(window, textvariable=v)
label.pack()
def list_rentals(self):
rentals = []
for i in self.__borepo.get_all():
r = Rental(
i.get_id(),
self.__dvdrepo.get_all()[self.__dvdrepo.find(
i.get_id_dvd())].get_name(), i.get_name_client())
rentals.append(r)
rentals = sorted(rentals, key=lambda x: x.dvd_name)
return rentals
def _loadFile(self):
try:
f = open(self._fileName, "rb")
res = pickle.load(f)
while res != "":
r = Rental(int(res.id), int(res.movie), int(res.client), res.rentedDate, res.dueDate, res.returnedDate)
Repository.store(self, r)
res = pickle.load(f)
except EOFError:
return []
except IOError as e:
raise RepositoryError(str(e))
def setUp(self):
self.repo = Repository()
self.brepo = Repository()
self.crepo = Repository()
self.Ucontroller = UndoController()
self.book = Book(21, 'titlu', 'descriere', 'author')
self.book2 = Book(22, 'titlu2', 'descriere2', 'author')
self.brepo.add(self.book)
self.brepo.add(self.book2)
self.client = Client(23, 'alex')
self.client2 = Client(24, 'ana')
self.client3 = Client(29, 'ana')
self.crepo.add(self.client)
self.crepo.add(self.client2)
self.rental = Rental(21236, 21, 24, date(2017, 11, 5),
date(2017, 12, 6), date(2017, 12, 5))
self.rental2 = Rental(21238, 22, 24, date(2017, 11, 5),
date(2017, 12, 6), date(2017, 12, 5))
self.rental3 = Rental(21238, 23, 24, date(2017, 11, 5),
date(2017, 12, 6), date(2017, 12, 5))
self.rental4 = Rental(21238, 21, 29, date(2017, 11, 5),
date(2017, 12, 6), date(2017, 12, 5))
self.rental5 = Rental(21231, 21, 23, date(2017, 11, 5),
date(2017, 10, 6), None)
self.controller = RentalController(self.repo, self.brepo, self.crepo,
self.Ucontroller)
self.ceva = LateRentalCount(12, 32)
self.altceva = BookRentalCount(12, 23)
self.nu = AuthorRentalCount('da', 23)
self.da = ClientRentalCount(32, 12)
def rentBook(self, bookId, clientId, currentDate, dueDate):
"""
:param currentDate:
:param bookId: int
:param clientId: int
:param dueDate: date
:return: a list of errors if any
"""
rentedDate = currentDate
dueDate = createDateFromString(dueDate)
# returnedDate = createDateFromString(returnedDate)
if bookId == -1 or clientId == -1 or currentDate is None:
return "Invalid input"
if rentedDate is None or dueDate is None:
return "Invalid date(s)"
if rentedDate > dueDate:
return "Inconsistent dates"
if self.__isBookRented(bookId):
return "Book already rented"
try:
book = self.__bookRepo.getById(bookId)
client = self.__clientRepo.getById(clientId)
except Exception as re:
return str(re)
rental = Rental(Rental.getNextId(), book.getId(), client.getId(), rentedDate, dueDate, None)
self.__rentalRepo.add(rental)
self.__bookRepo.getById(bookId).setRented(True)
self.__stats.addBookToStats(self.__bookRepo.getById(bookId))
return ""
def toDomain(rentalResource):
rental = Rental()
rental.id = rentalResource[
RentalField.ID] if RentalField.ID in rentalResource else None
rental.customer = rentalResource[
RentalField.
CUSTOMER] if RentalField.CUSTOMER in rentalResource else None
rental.property = rentalResource[
RentalField.
PROPERTY] if RentalField.PROPERTY in rentalResource else None
rental.agent = rentalResource[
RentalField.AGENT] if RentalField.AGENT in rentalResource else None
rental.rent = rentalResource[
RentalField.RENT] if RentalField.RENT in rentalResource else None
rental.start = Date.formatDate(
rentalResource[RentalField.START]
) if RentalField.START in rentalResource else None
rental.end = Date.formatDate(rentalResource[
RentalField.END]) if RentalField.END in rentalResource else None
rental.status = rentalResource[
RentalField.
STATUS] if RentalField.STATUS in rentalResource else None
return rental
def both_return(self, ID):
try:
self.__Rcontroller.returnBook(int(ID.get()))
messagebox.showinfo(
"INFO", "BOOK RETURNED\n" + str(
Rental.printReturned(
self.__Rcontroller.getRental(int(ID.get())))))
except ArithmeticError as exc:
window = Toplevel(self.master)
window.pack_propagate(0)
v = StringVar()
v.set(str(exc))
label = Label(window, textvariable=v)
label.pack()
def _addRental(self, userId, bookElement):
'''
Adds rental to _repo.
'''
if self._repo.findId(userId) == False:
if self._bookController.getNumberOf(bookElement.getId()) > 0:
newElement = Rental(userId, bookElement, self._lastId)
self._repo.addElement(newElement)
addOperation = AddOperation(self._repo, newElement)
self._undoController._addOperation(addOperation)
self._bookController.modifyNumberOf(
bookElement.getId(),
self._bookController.getNumberOf(bookElement.getId()) - 1)
self._lastId += 1
return True
else:
raise RentalException("No more books in repository!")
return False
elif self._repo.findId(userId) == True:
element = self._repo.getElementList()
for i in element:
if i.getId() == userId and i.getRentedBook() == bookElement:
raise RentalException("That client already rented " +
bookElement.getTitle())
return False
if self._bookController.getNumberOf(bookElement.getId()) > 0:
newElement = Rental(userId, bookElement, self._lastId)
self._repo.addElement(newElement)
addOperation = AddOperation(self._repo, addOperation)
self._undoController._addOperation(addOperation)
self._lastId += 1
self._bookController.modifyNumberOf(
bookElement.getId(),
self._bookController.getNumberOf(bookElement.getId()) - 1)
return True
else:
raise RentalException("Client already has that book!")
def _loadFromFile(self):
try:
f = open(self._fName, "r")
except IOError:
return
line = f.readline().strip()
while line != "":
t = line.split(";")
car = self._carRepo.find(int(t[1]))
client = self._clientRepo.find(int(t[2]))
c = Rental(t[0], datetime.strptime(t[3], "%Y-%m-%d"),
datetime.strptime(t[4], "%Y-%m-%d"), client, car)
Repository.store(self, c)
line = f.readline().strip()
f.close()
def writeToBinaryFile(self):
rentals = []
rental = Rental(1414, 1035, 1078, datetime.date(2019, 10, 23),
datetime.date(2019, 10, 30),
datetime.date(2019, 10, 27))
rentals.append(rental)
clients = []
names = ["Mike", "Jake", "Maria", "Andrei", "Dan", "Ana", "Diana"]
for i in range(20):
clients.append(Client(i * 134 + 51, random.choice(names)))
movies = []
titles0 = [
"Avengers", "A Star Wars Story", "Jurassic World", "Incredibles",
"Venom", "The Last Jedi", "Deadpool"
]
descriptions = [
"A man suffering from Alzheimer's embarks on a final road trip with his granddaughter.",
"A couple find themselves in over their heads when they foster three children.",
"A young couple's decision to get engaged threatens to break them apart."
]
genres = ["drama", "comedy", "musical", "thriller", "action", "Sci-Fi"]
for i in range(10):
title = random.choice(titles0)
desc = random.choice(descriptions)
genre = random.choice(genres)
movies.append(Movie(i * 156 + 46, title, desc, genre))
f = open("movies.pickle", "wb")
for m in movies:
pickle.dump(m, f)
f.close()
f = open("clients.pickle", "wb")
for c in clients:
pickle.dump(c, f)
f.close()
f = open("rentals.pickle", "wb")
for r in rentals:
pickle.dump(r, f)
f.close()
def createRental(self, rentalId, client, car, start, end, recordUndo=True):
rental = Rental(rentalId, start, end, client, car)
'''
Check the car's availability for the given period
'''
if self.isCarAvailable(rental.car, rental.start, rental.end) == False:
raise Exception("Car is not available during that time!")
self.__repository.store(rental)
'''
If the operation did not raise an Exception, then we record it for Undo/Redo
'''
if recordUndo == True:
redo = FunctionCall(self.createRental, rentalId, client, car,
start, end)
undo = FunctionCall(self.deleteRental, rentalId)
cascadeOp = CascadedOperation(Operation(redo, undo))
self._undoController.recordOperation(cascadeOp)
return rental
class TestRentalController(unittest.TestCase):
def setUp(self):
self.repo = Repository()
self.brepo = Repository()
self.crepo = Repository()
self.Ucontroller = UndoController()
self.book = Book(21, 'titlu', 'descriere', 'author')
self.book2 = Book(22, 'titlu2', 'descriere2', 'author')
self.brepo.add(self.book)
self.brepo.add(self.book2)
self.client = Client(23, 'alex')
self.client2 = Client(24, 'ana')
self.client3 = Client(29, 'ana')
self.crepo.add(self.client)
self.crepo.add(self.client2)
self.rental = Rental(21236, 21, 24, date(2017, 11, 5),
date(2017, 12, 6), date(2017, 12, 5))
self.rental2 = Rental(21238, 22, 24, date(2017, 11, 5),
date(2017, 12, 6), date(2017, 12, 5))
self.rental3 = Rental(21238, 23, 24, date(2017, 11, 5),
date(2017, 12, 6), date(2017, 12, 5))
self.rental4 = Rental(21238, 21, 29, date(2017, 11, 5),
date(2017, 12, 6), date(2017, 12, 5))
self.rental5 = Rental(21231, 21, 23, date(2017, 11, 5),
date(2017, 10, 6), None)
self.controller = RentalController(self.repo, self.brepo, self.crepo,
self.Ucontroller)
self.ceva = LateRentalCount(12, 32)
self.altceva = BookRentalCount(12, 23)
self.nu = AuthorRentalCount('da', 23)
self.da = ClientRentalCount(32, 12)
def test_controller(self):
self.Ucontroller.newOperation()
self.controller.addRental(self.rental2)
self.assertEqual(len(self.repo), 1)
self.assertEqual(self.controller.getRental(21238).getID(), 21238)
self.assertRaises(ControllerException, self.controller.addRental,
self.rental3)
self.assertRaises(ControllerException, self.controller.addRental,
self.rental4)
self.book2.set_available(False)
self.assertRaises(ControllerException, self.controller.addRental,
self.rental2)
self.assertRaises(ControllerException, self.controller.returnBook,
13123124)
self.Ucontroller.newOperation()
self.controller.addRental(self.rental)
self.assertEqual(self.controller.returnBook(21236), self.rental)
self.assertEqual(len(self.controller.getAllRental()), 2)
self.assertEqual(len(self.controller.mostRentedBooks()), 2)
self.assertEqual(len(self.controller.mostActiveClients()), 2)
self.assertEqual(len(self.controller.mostRentedAuthors()), 1)
self.controller.deleteRental(self.rental.getID())
self.Ucontroller.newOperation()
self.controller.addRental(self.rental5)
self.assertEqual(len(self.controller.lateRentals()), 1)
self.assertEqual(self.ceva.getBook(), 12)
self.assertEqual(self.ceva.getCount(), 32)
self.assertFalse(self.ceva > self.ceva)
self.assertEqual(str(self.ceva),
'Book 12 has been overdue for 32 days')
self.assertEqual(self.altceva.getCount(), 23)
self.assertEqual(self.altceva.getBook(), 12)
self.assertFalse(self.altceva > self.altceva)
self.assertEqual(str(self.altceva), 'Book 12 was rented 23 times')
self.assertEqual(self.nu.getBook(), 'da')
self.assertEqual(self.nu.getCount(), 23)
self.assertEqual(str(self.nu), 'Author da was rented for 23 times')
self.assertFalse(self.nu > self.nu)
self.assertFalse(self.da > self.da)
self.assertEqual(str(self.da),
'Client 32 has rented books for 12 days')
self.assertEqual(self.da.getCount(), 12)
self.assertEqual(self.da.getBook(), 32)
class TestDomain(unittest.TestCase):
def setUp(self):
self.client = Client(23, 'alex')
self.client2 = Client(12, 'diana')
self.book = Book(21, 'titlu', 'descriere', 'author')
self.book2 = Book(22, 'titlu2', 'descriere2', 'author2')
self.rental = Rental(21236, 21, 23, date(2017, 11, 5), date(2017, 12, 6), date(2017, 12, 5))
self.rental2 = Rental(21236, 21, 23, date(2017, 11, 5), date(2017, 12, 6), date(2017, 12, 5))
def tearDown(self):
pass
def test_create_Client(self):
# CLIENTS TESTS
self.assertEqual(23, self.client.getID())
self.assertEqual('alex', self.client.getName())
self.client.setName('da')
self.assertEqual('da', self.client.getName())
self.assertFalse(self.client == self.client2)
self.assertEqual(str(self.client), '023. da\n')
self.assertEqual(self.client.create_client(23, 'alex'), self.client)
def test_create_book(self):
self.assertEqual(21, self.book.getID())
self.assertEqual('titlu', self.book.getTitle())
self.assertEqual('descriere', self.book.getDescription())
self.assertEqual('author', self.book.getAuthor())
self.assertEqual(True, self.book.get_available())
self.book.setTitle('lol')
self.assertEqual('lol', self.book.getTitle())
self.book.setAuthor('da')
self.assertEqual('da', self.book.getAuthor())
self.book.setDescription('da')
self.assertEqual('da', self.book.getDescription())
self.assertEqual(str(self.book), '021. lol by da\n->da\nStatus: Available\n')
self.book.set_available(False)
self.assertEqual(False, self.book.get_available())
self.assertEqual(str(self.book), '021. lol by da\n->da\nStatus: Unavailable\n')
self.assertNotEqual(self.book, self.book2)
self.assertEqual(self.book.create_book(21, 'titlu', 'descriere', 'author'), self.book)
def test_create_rental(self):
self.assertEqual(21236, self.rental.getID())
self.assertEqual(21, self.rental.getBookID())
self.assertEqual(23, self.rental.getClientID())
self.assertEqual(date(2017, 12, 6), self.rental.getDueDate())
self.assertEqual(date(2017, 11, 5), self.rental.getRentedDate())
self.assertEqual(date(2017, 12, 5), self.rental.getReturnedDate())
self.assertEqual('Rental 21236: book: 21 rented by client 23 on 05.11.2017 and is due by 06.12.2017', str(self.rental))
self.rental.setBookID(21)
self.rental.setClientID(23)
self.rental.setReturnedDate(date(2017, 12, 12))
self.rental.setDueDate(date(2017, 11, 21))
self.rental.setRentedDate(date(2017, 9, 23))
self.assertEqual(len(self.rental), 80)
self.rental.setReturnedDate(None)
self.assertEqual(len(self.rental), 0)
self.assertEqual(self.rental.getDelay(), (date.today()-self.rental.getDueDate()).days)
self.assertEqual(self.rental, self.rental2)
self.rental.setReturnedDate(date(2017, 12, 12))
self.assertEqual(self.rental.create_rental(21, 23, 12, 5).getBookID(), 21)
self.assertEqual(self.rental.printReturned(self.rental), 'Rental 21236: book: 21 rented by client 23 on 23.09.2017 was returned on 12.12.2017')
def mainMenu(self):
UI.printMenu()
while True:
try:
command = input("enter command ").strip()
if command == '1':
book = UI.read_book()
self.__Ucontroller.newOperation()
self.__Bcontroller.addBook(book)
print("book added")
elif command == '2':
client = UI.read_client()
self.__Ucontroller.newOperation()
self.__Ccontroller.addClient(client)
print("client added")
elif command == '3':
ID = self.readInt("Book ID to be removed: ")
self.__Ucontroller.newOperation()
self.__Bcontroller.removeBook(ID)
print("Book removed")
elif command == '4':
ID = self.readInt("Client ID to be removed: ")
self.__Ucontroller.newOperation()
self.__Ccontroller.removeClient(ID)
print("Client removed")
elif command == '5':
print("Book to be updated: ")
newbook = UI.read_book()
self.__Ucontroller.newOperation()
self.__Bcontroller.updateBook(newbook)
print("book updated")
elif command == '6':
print("client to be updated: ")
self.__Ucontroller.newOperation()
newclient = UI.read_client()
self.__Ccontroller.updateClient(newclient)
print("client updated")
elif command == '7':
for x in self.__Bcontroller.getAllBooks():
print(str(x))
elif command == '8':
for x in self.__Ccontroller.getAllClients():
print(str(x))
elif command == '9':
rental = UI.read_rental()
self.__Ucontroller.newOperation()
self.__Rcontroller.addRental(rental)
print(rental)
elif command == '10':
for x in self.__Rcontroller.getAllRental():
print(str(x))
elif command == '11':
rentalID = self.readInt("Enter rental ID: ")
self.__Rcontroller.returnBook(rentalID)
print(
Rental.printReturned(
self.__Rcontroller.getRental(rentalID)))
elif command == '12':
substring = input("Enter keywords: ").lower()
for x in self.__Bcontroller.searchBook(substring):
print(str(x))
elif command == '13':
substring = input("Enter keywords: ").lower()
for x in self.__Ccontroller.searchClient(substring):
print(str(x))
elif command == '14':
for x in self.__Rcontroller.mostRentedBooks():
print(x)
elif command == '15':
for x in self.__Rcontroller.mostActiveClients():
print(x)
elif command == '16':
for x in self.__Rcontroller.mostRentedAuthors():
print(x)
elif command == '17':
for x in self.__Rcontroller.lateRentals():
print(x)
elif command == '18':
self.__Ucontroller.undo()
elif command == '19':
self.__Ucontroller.redo()
elif command == 'help':
UI.printMenu()
else:
print(
"Invalid command. Type 'help' to see available commands"
)
except Exception as exc:
print(str(exc))
def setUp(self):
self.v = RentalValidator()
self.c = Rental("1", "2", "3", datetime.date(2019, 11, 20),
datetime.date(2019, 11, 27),
datetime.date(2019, 11, 23))
def checkUniqueness(errors, rental, original=Rental()):
return errors
def testDomainRental(self):
rental = Rental(Rental.getNextId(), 2, 3, createDateFromString("11.12.2017"),
createDateFromString("20.12.2017"), None)
self.assertTrue(rental.getBookId() == 2)
self.assertTrue(rental.getClientId() == 3)
self.assertTrue(rental.getRentedDate() == date(2017, 12, 11))
self.assertTrue(rental.getDueDate() == date(2017, 12, 20))
self.assertTrue(rental.getReturnDate() is None)
rental.setReturnDate(date(2017, 12, 15))
x = str(rental)
self.assertTrue(rental.getReturnDate() == date(2017, 12, 15))
