def del_client(client_id):
try:
ClientService.delete_client(int(client_id))
return "", 205
except ResourceNotFound as r:
return r.message, 404
def test_add_client_serv():
cl_val = ClientValidator()
cl_repo = ClientRepository(cl_val)
cl_serv = ClientService(cl_repo)
cl_serv.add_cl_srv(1, "Geo", "Valcea")
assert len(cl_repo.get_all_clients()) == 1
assert cl_repo.get_all_clients()[0].get_cl_name() == "Geo"
def del_client(client_id):
try:
ClientService.delete_client(int(client_id))
return '', 204
except ValueError as e:
return 'Not a valid ID', 400
except ResourceNotFound as r:
return r.message, 404
def put_client(client_id):
try:
client = Client.json_parse(request.json)
client.client_id = int(client_id)
ClientService.update_client(client)
return jsonify(client.json()), 200
except ResourceNotFound as r:
return r.message, 404
def setUp(self):
self.__ID = 13
self.__client = Client(1, "Silviu", "Anton", 1990722170051)
self.__movie = Movie(1, "Saw", "a movie about a psycho", "Horror")
self.__date = date.today()
self.__rent = Rent(self.__ID, self.__client, self.__movie, self.__date)
self.__validator = RentValidator()
self.__repo = RentFileRepository("testRent.txt")
self.__movieRepo = FileRepository("testMovie.txt", Movie)
self.__clientRepo = FileRepository("testClient.txt", Client)
self.__service = RentService(self.__repo, self.__validator, self.__clientRepo, self.__movieRepo)
self.__clientService = ClientService(self.__clientRepo, ClientValidator())
self.__movieService = MovieService(self.__movieRepo, MovieValidator())
def setUp(self):
self.__ID = 13
self.__firstName = "Silviu"
self.__lastName = "Anton"
self.__CNP = 1990722170051
self.__client = Client(self.__ID, self.__firstName, self.__lastName, self.__CNP)
self.__validator = ClientValidator()
self.__badID = 5
self.__badFirstName = ""
self.__badLastName = ""
self.__badCNP = 12654
self.__badClient = Client(self.__badID, self.__badFirstName, self.__badLastName, self.__badCNP)
self.__repo = FileRepository("testClient.txt", Client)
self.__service = ClientService(self.__repo, self.__validator)
def get_client(id):
client = ClientService.get_client(id)
if client:
return client, 200
else:
logger.log(f"Client not found with id of {id}", logging.INFO)
return "Client Not Found", 404
def get_topics_by_text():
req = {
"public_id": request.headers.get('TPS_PUBLIC_ID', ""),
"secret": request.headers.get("TPS_SECRET_KEY", ""),
"text": request.args.get("text", "")
}
try:
ClientService.check_access(request=req)
tps = TopicPredictorService(topic_model=topic_model)
return jsonify(tps.predict_topics(text=req["text"]))
except AccessDeniedException as e:
return jsonify({"message": str(e)}), 403
except Exception:
return jsonify({"message": "Internal server error"}), 500
def get_client_accounts(client_id):
account_list = ClientService.get_client_accounts(client_id)
if len(account_list) != 0:
return str(account_list), 200
else:
return f"Id:{client_id} NOT FOUND", 404
def delete_client(id):
delete_count = ClientService.delete_client(id)
if delete_count > 0:
return f"Deleted {delete_count} items", 204
else:
logger.log(f"Client could not be deleted with an id of {id}")
return "Client Not Found", 404
def get_client(client_id):
try:
client = ClientService.get_client(client_id)
return jsonify(client.json()), 200
except ValueError as e:
return "Not a valid ID", 400
except ResourceNotFound as r:
return r.message, 404
def get_client(client_id):
try:
client = ClientService.get_client_by_id(int(client_id))
return jsonify(client), 200
except ValueError as e:
return 'Not a valid ID', 400
except ResourceNotFound as r:
return r.message, 404
def delete_client(client_id):
try:
client = ClientService.delete_client(int(client_id))
return jsonify(client.json()), 205
except ResourceNotFound as r:
return r.message, 404
except BadRequestInput as bri:
return bri.messaeg, 400
def update_client(id):
client = Client.deserialize(request.json)
client.id = id
update_count = ClientService.update_client(client)
if update_count > 0:
return f"Successfully updated {update_count} item", 200
else:
logger.log(f"Client could not be updated with an id of {id}\n{request.json}")
return "Client Not Found", 404
def get_client(client_id):
try:
client = ClientService.get_client_by_id(int(client_id))
return jsonify(client.json()), 200
except ValueError as e:
return "Not a valid client ID.", 400
# Bad request
except ResourceNotFound as r:
return r.message, 404
def put_client(client_id):
try:
client = Client.json_parse_client(request.json)
client.client_id = int(client_id)
client = ClientService.update_client(client)
return jsonify(client), 200
except ValueError as e:
return 'Not a valid ID', 400
except ResourceNotFound as r:
return r.message, 404
from repository.client_file_repo import ClientFileRepository
from repository.client_repository import ClientRepository
from repository.rental_repository import RentalRepository
from services.car_service import CarService
from services.client_service import ClientService
from services.rental_service import RentalService
from ui.user_interface import UI
'''
The module where our application will start
'''
cl_val = ClientValidator()
car_val = CarValidator()
rt_val = RentalValidator()
#cl_rep = ClientRepository(cl_val)
cl_rep_file = ClientFileRepository("clients.txt")
#car_rep = CarRepository(car_val)
car_rep_file = CarFileRepository("cars.txt")
car_rep_file.remove_all()
rt_rep = RentalRepository(rt_val)
cl_serv = ClientService(cl_rep_file)
car_serv = CarService(car_rep_file)
rt_serv = RentalService(rt_rep, cl_rep_file, car_rep_file)
ui = UI(car_serv, cl_serv, rt_serv)
ui.show_ui()
'''
Created on Nov 6, 2018
Modulul principal al aplicatiei
@author: Silviu Anton
'''
from services.client_service import ClientService
from services.movie_service import MovieService
from infrastructure.repository import FileRepository, RentFileRepository
from domain.validators import ClientValidator, MovieValidator, RentValidator
from ui.console import Console
from services.rent_service import RentService
from domain.entities import Client, Movie
if __name__ == '__main__':
clientRepository = FileRepository('clienti.txt', Client)
clientService = ClientService(clientRepository, ClientValidator())
movieRepository = FileRepository('filme.txt', Movie)
movieService = MovieService(movieRepository, MovieValidator())
rentRepository = RentFileRepository('inchirieri.txt')
rentService = RentService(rentRepository, RentValidator(),
clientRepository, movieRepository)
console = Console(clientService, movieService, rentService)
console.run()
def test_94_delete(self):
self.assertTrue(
ClientService.delete_client(ClientServiceTest.client.id))
def test_93_update(self):
ClientServiceTest.client.name = "Updated Test Client"
self.assertTrue(ClientService.update_client(ClientServiceTest.client))
def test_03_get_one(self):
self.assertTrue(ClientService.get_client(ClientServiceTest.client.id))
def test_02_get_all(self):
clients = ClientService.get_all_clients()
ClientServiceTest.client = Client.deserialize(clients.pop())
self.assertTrue(clients)
def test_01_insert(self):
self.assertTrue(ClientService.create_client(ClientServiceTest.client))
def post_client():
client = Client.json_parse(request.json)
client = ClientService.create_client(client)
return jsonify(client.json()), 201
def delete_client(client_id):
try:
ClientService.delete_client(int(client_id))
return '', 205
except ValueError as e:
return f"No id:{client_id}", 404
def get_client(client_id):
try:
client = ClientService.get_client_by_id(int(client_id))
return jsonify(client.json()), 200
except ResourceNotFound as r:
return r.message, 404
def get_all_clients():
return jsonify(str(ClientService.all_clients())), 200
class TestClient(unittest.TestCase):
def setUp(self):
self.__ID = 13
self.__firstName = "Silviu"
self.__lastName = "Anton"
self.__CNP = 1990722170051
self.__client = Client(self.__ID, self.__firstName, self.__lastName, self.__CNP)
self.__validator = ClientValidator()
self.__badID = 5
self.__badFirstName = ""
self.__badLastName = ""
self.__badCNP = 12654
self.__badClient = Client(self.__badID, self.__badFirstName, self.__badLastName, self.__badCNP)
self.__repo = FileRepository("testClient.txt", Client)
self.__service = ClientService(self.__repo, self.__validator)
def testEntity(self):
self.assertEqual(self.__client.getID(), self.__ID)
def testValidator(self):
self.__validator.validate(self.__client)
self.assertRaises(ValidError, self.__validator.validate, self.__badClient)
def testRepository(self):
self.assertEqual(self.__repo.size(), 0)
self.__repo.store(self.__client)
self.assertEqual(self.__repo.size(), 1)
self.assertRaises(DuplicateError, self.__repo.store, self.__client)
self.assertEqual(len(self.__repo.get_all()), 1)
self.assertEqual(self.__repo.size(), 1)
self.__repo.delete(self.__ID)
self.assertEqual(self.__repo.size(), 0)
self.__repo.clearFile()
def testService(self):
self.__service.add_client("Silviu", "Anton", 1990722170051)
self.assertEqual(len(self.__service.get_all()), 1)
self.__service.modify_client(1, "Constantin", "Anton", 1990722170052)
self.assertEqual(self.__service.findByID(1).getCNP(), 1990722170052)
self.__service.modify_client_name(1, "Anton", "Constantin")
self.assertEqual(self.__service.findByID(1).getName(), "Anton Constantin")
self.__service.generate_clients(4)
self.assertEqual(self.__service.number_of_clients(), 5)
self.__repo.clearFile()
self.assertEqual(self.__service.number_of_clients(), 0)
class TestRent(unittest.TestCase):
def setUp(self):
self.__ID = 13
self.__client = Client(1, "Silviu", "Anton", 1990722170051)
self.__movie = Movie(1, "Saw", "a movie about a psycho", "Horror")
self.__date = date.today()
self.__rent = Rent(self.__ID, self.__client, self.__movie, self.__date)
self.__validator = RentValidator()
self.__repo = RentFileRepository("testRent.txt")
self.__movieRepo = FileRepository("testMovie.txt", Movie)
self.__clientRepo = FileRepository("testClient.txt", Client)
self.__service = RentService(self.__repo, self.__validator, self.__clientRepo, self.__movieRepo)
self.__clientService = ClientService(self.__clientRepo, ClientValidator())
self.__movieService = MovieService(self.__movieRepo, MovieValidator())
def testEntity(self):
self.assertEqual(self.__rent.getID(), self.__ID)
def testValidator(self):
self.__validator.validate(self.__rent)
def testRepository(self):
self.assertEqual(self.__repo.size(), 0)
self.__repo.store(self.__rent)
self.assertEqual(self.__repo.size(), 1)
self.assertRaises(DuplicateError, self.__repo.store, self.__rent)
self.assertEqual(len(self.__repo.get_all()), 1)
self.assertEqual(self.__repo.size(), 1)
self.__repo.delete(self.__ID)
self.assertEqual(self.__repo.size(), 0)
self.__repo.clearFile()
def testService(self):
self.__clientService.add_client("Silviu", "Anton", 1990722170051)
self.__movieService.add_movie("Saw", "a movie about a psycho", "Horror")
self.__service.add_rent(self.__client, self.__movie)
self.assertEqual(len(self.__service.get_all()), 1)
self.assertRaises(DuplicateError, self.__service.add_rent, self.__client, self.__movie)
self.assertEqual(self.__service.getIDbyClientAndMovie(self.__client, self.__movie), 1)
self.assertEqual(self.__service.number_of_rents(), 1)
self.__service.rentReturn(1)
self.__clientRepo.clearFile()
self.__movieRepo.clearFile()
self.assertEqual(self.__service.number_of_rents(), 0)
self.__clientService.add_client("Silviu", "Anton1", 1111111111111)
self.__clientService.add_client("Silviu", "Anton2", 1111111111112)
self.__clientService.add_client("Silviu", "Anton3", 1111111111113)
self.__movieService.add_movie("Saw", "desc", "Action/Adventure")
self.__movieService.add_movie("Saw2", "desc", "Horror/Adventure")
self.__movieService.add_movie("Saw3", "desc", "Thriller")
self.__movieService.add_movie("Saw4", "desc", "Thriller/Horror/Adventure")
self.__service.add_rent(self.__clientService.findByID(1), self.__movieService.findByTitle("Saw"))
self.__service.add_rent(self.__clientService.findByID(1), self.__movieService.findByTitle("Saw2"))
self.__service.add_rent(self.__clientService.findByID(1), self.__movieService.findByTitle("Saw4"))
self.__service.add_rent(self.__clientService.findByID(2), self.__movieService.findByTitle("Saw"))
self.__service.add_rent(self.__clientService.findByID(2), self.__movieService.findByTitle("Saw3"))
self.__service.add_rent(self.__clientService.findByID(2), self.__movieService.findByTitle("Saw4"))
self.__service.add_rent(self.__clientService.findByID(3), self.__movieService.findByTitle("Saw2"))
self.__service.add_rent(self.__clientService.findByID(3), self.__movieService.findByTitle("Saw3"))
self.assertEqual(self.__service.topClientsWithRentedMoviesByGenre("Adventure"), [("Silviu Anton1", 3),("Silviu Anton2", 2),("Silviu Anton3", 1)])
self.__repo.clearFile()
self.__clientRepo.clearFile()
self.__movieRepo.clearFile()
def create_client():
ClientService.create_client(Client.deserialize(request.json))
logger.log(request.json, logging.INFO)
return "Success!", 201
