def get_reviews_for_movie(movie_rank: int, repo: AbstractRepository): movie = repo.get_movie_by_rank(movie_rank) if movie is None: raise ServicesException('Movie does not exist in the repository') return repo.get_reviews_for_movie(movie)
def get_reviews_for_movie(movie_rank, repo: AbstractRepository): movie = repo.get_movie(movie_rank) if movie is None: raise NonExistentMovieException reviews = repo.get_reviews() review_list = [] for review in reviews: if review.movie == movie: review_list.append(review) return reviews_to_dict(review_list)
def get_random_movies(quantity, repo: AbstractRepository): movie_count = repo.get_number_of_movies() if quantity >= movie_count: # Reduce quantity of ranks to generate if repo has insufficient number of movies. quantity = movie_count - 1 # Pick distinct and random movies. random_ranks = random.sample(range(1, movie_count), quantity) movies = repo.get_movies_by_rank(random_ranks) return movies_to_dict(movies)
def add_user(username: str, password: str, repo: AbstractRepository): # Check that the given username is available. user = repo.get_user(username) if user is not None: raise NameNotUniqueException # Encrypt password so that the database doesn't store passwords 'in the clear'. password_hash = generate_password_hash(password) # Create and store the new User, with password encrypted. user = User(username, password_hash) repo.add_user(user)
def add_user(user_name: str, password: str, repo: AbstractRepository): # Check that the given username is available and not currently used in repository user = repo.get_user(user_name) if user is not None: raise NameNotUniqueException # Encrypt password so that the database doesn't store passwords in plain text format. password_hash = generate_password_hash(password) # Create and store the new User with an encrypted password user = User(user_name, password_hash) repo.add_user(user)
def remove_movie_from_watchlist(username: str, movie_title: str, movie_year: int, repo: AbstractRepository): # Check user exists user = repo.get_user(username) if user is None: raise UnknownUserException # Check movie exists movie = repo.get_movie_by_title_and_year(movie_title, movie_year) if movie is None: raise NonExistentMovieException repo.remove_movie_from_user_watchlist(user, movie)
def add_review(movie_rank: int, review_text: str, rating: int, username: str, repo: AbstractRepository): # Check that the movie exists. movie = repo.get_movie(movie_rank) if movie is None: raise NonExistentMovieException user = repo.get_user(username) if user is None: raise UnknownUserException # Create review. review = Review(movie, review_text, rating) # Update the repository. repo.add_review(review)
def add_review(movie_title: str, movie_year: int, username: str, review_text: str, rating: int, repo: AbstractRepository): # Check movie and user exists movie = repo.get_movie_by_title_and_year(movie_title, movie_year) if movie is None: raise NonExistentMovieException user = repo.get_user(username) if user is None: raise UnknownUserException # Create review review = make_review(user, movie, review_text, rating) # Add review repo.add_review(review)
def get_reviews_for_movie(movie_title, movie_year, repo: AbstractRepository): movie = repo.get_movie_by_title_and_year(movie_title, movie_year) if movie is None: raise NonExistentMovieException return reviews_to_dict(movie.reviews)
def get_movie_by_title_and_year(title: str, year: int, repo: AbstractRepository): movie = repo.get_movie_by_title_and_year(title, year) if movie is None: raise NonExistentMovieException return movie_to_dict(movie)
def get_user_watchlist(username: str, repo: AbstractRepository): # Check user exists user = repo.get_user(username) if user is None: raise UnknownUserException return watchlist_to_dict(user.watchlist)
def authenticate_user(username: str, password: str, repo: AbstractRepository): authenticated = False user = repo.get_user(username) if user is not None: authenticated = check_password_hash(user.password, password) if not authenticated: raise AuthenticationException
def create_review(movie_rank: int, review_text: str, rating: int, user_name: str, repo: AbstractRepository): # Check that the Movie exists. movie = repo.get_movie_by_rank(movie_rank) if movie is None: raise ServicesException('Movie does not exist in the repository') # Check that the user exists. user = repo.get_user(user_name) if user is None: raise ServicesException('User does not exist in the repository') # Create review review = Review(movie, review_text, rating) # Add review to list of user reviews (and consequently to list of Movie reviews) user.add_review(review) # Update the repository with new Review. repo.add_review(review)
def get_movies_by_genre(genre: str, repo: AbstractRepository): movies = repo.get_movies_by_genre(genre) return movies_to_dict(movies)
def get_movies_by_title(title: str, repo: AbstractRepository): movies = repo.get_movies_by_title(title) return movies_to_dict(movies)
def get_all_movies(repo: AbstractRepository): all_movies = repo.get_all_movies() return movies_to_dict(all_movies)
def get_user(user_name: str, repo: AbstractRepository): user = repo.get_user(user_name) if user is None: raise UnknownUserException return user
def get_movies_by_rank(rank_list: List[int], repo: AbstractRepository): movies = repo.get_movies_by_rank(rank_list) return movies
def get_actor(actor_full_name: str, repo: AbstractRepository) -> Actor: actor = repo.get_actor(actor_full_name) if actor is None: raise ServicesException('Actor does not exist in the repository') return actor
def get_review(review_id: int, repo: AbstractRepository) -> Review: review = repo.get_review(review_id) if review is None: raise ServicesException('Review does not exist in the repository') return review
def get_movie_ranks_by_director(director: Director, repo: AbstractRepository) -> List[int]: movie_ranks = repo.get_movie_ranks_by_director(director) return movie_ranks
def get_movie_ranks_by_actors(actor_list: List[Actor], repo: AbstractRepository) -> List[int]: movie_ranks = repo.get_movie_ranks_by_actors(actor_list) return movie_ranks
def get_movie_ranks_by_genres(genre_list: List[Genre], repo: AbstractRepository) -> List[int]: movie_ranks = repo.get_movie_ranks_by_genres(genre_list) return movie_ranks
def get_movies(repo: AbstractRepository): return repo.get_movies()
def get_movies_by_director(director_full_name: str, repo: AbstractRepository): movies = repo.get_movies_by_director(director_full_name) return movies_to_dict(movies)
def get_most_common_actor_names(quantity: int, repo: AbstractRepository) -> List[str]: actors = repo.get_most_common_actors(quantity) actor_names = [actor.actor_full_name for actor in actors] return actor_names
def get_genre_names(repo: AbstractRepository): genres = repo.get_genres() genre_names = [genre.genre_name for genre in genres] return genre_names
def get_most_common_genre_names(quantity: int, repo: AbstractRepository) -> List[str]: genres = repo.get_most_common_genres(quantity) genre_names = [genre.genre_name for genre in genres] return genre_names
def get_movie_ranks_by_release_year(release_year: int, repo: AbstractRepository) -> List[int]: movie_ranks = repo.get_movie_ranks_by_release_year(release_year) return movie_ranks
def get_most_common_director_names(quantity: int, repo: AbstractRepository) -> List[str]: directors = repo.get_most_common_directors(quantity) director_names = [director.director_full_name for director in directors] return director_names