def get_related_movie(a_class, name, repo: AbstractRepository): if a_class == 'director': movies = repo.get_movies_by_director(name) else: movies = repo.get_movies_by_actor(name) return movies
def search(search_text, repo: AbstractRepository): result_dict = {} search_text = search_text.strip().lower() count = 0 #find related movie for movie in repo.get_movies(): if search_text in movie.title.lower(): count += 1 if "Movie" not in result_dict: result_dict["Movie"] = [movie] else: result_dict["Movie"].append(movie) #find related actor for actor in repo.get_actors(): if search_text in actor.actor_full_name.lower(): count += 1 if "Actor" not in result_dict: result_dict["Actor"] = [actor] else: result_dict["Actor"].append(actor) #find related director for director in repo.get_directors(): if search_text in director.director_full_name.lower(): count += 1 if "Director" not in result_dict: result_dict["Director"] = [director] else: result_dict["Director"].append(director) return result_dict, count
def get_10_movie(condition, repo: AbstractRepository): movies = [] #generate 10 random movies if condition == 'random': random_rank_list = random.sample( range(12, repo.get_number_of_movies() + 1), 10) for rank in random_rank_list: movies.append(repo.get_movie(rank)) #all genres else: all_genre_movies = [] for genre in condition: all_genre_movies += [ movie for movie in repo.get_movies_by_genre(genre.genre_name) if movie not in all_genre_movies ] if len(all_genre_movies) >= 10: random_index_list = random.sample(range(len(all_genre_movies)), 10) else: #less than 10 movies among all the genres random_index_list = random.sample(range(len(all_genre_movies)), len(all_genre_movies)) for index in random_index_list: movies.append(all_genre_movies[index]) if movies is []: raise NonExistentMovieException return movies
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_total_number_of_movies_in_repo() if quantity >= movie_count: # Reduce the quantity of movie ids to generate if the repository has an insufficient number of movies quantity = movie_count - 1 # Pick distinct and random movie random_ids = random.sample(range(1, movie_count), quantity) movies = repo.get_movies_by_index(random_ids) 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 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 get_movies_by_release_year(year, repo: AbstractRepository): movies = repo.get_movies_by_release_year(target_year=year) movies_dto = list() prev_year = next_year = None if len(movies) > 0: prev_year = repo.get_release_year_of_previous_movie(movies[0]) next_year = repo.get_release_year_of_next_movie(movies[0]) # Convert Movies to dictionary form. movies_dto = movies_to_dict(movies) return movies_dto, prev_year, next_year
def add_review(rank: int, review_txt: str, rating: int, username: str, repo: AbstractRepository): # Check that the movie exists. movie = repo.get_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_txt, rating) # Update the repository. repo.add_review(review)
def search_movie_by_actor_and_director(actor_fullname: str, director_fullname: str, repo: AbstractRepository): movies = repo.search_movies_by_actor_and_director(actor_fullname, director_fullname) if len(movies) == 0: raise NoSearchResultsException movies_as_dict = movies_to_dict(movies) return movies_as_dict
def get_movie(movie_id: int, repo: AbstractRepository): movie = repo.get_movie_by_index(movie_id) if movie is None: raise NonExistentMovieException return movie_to_dict(movie)
def get_movies_by_id(id_list, repo: AbstractRepository): movies = repo.get_movies_by_index(id_list) # Convert Movies to dictionary form movies_as_dict = movies_to_dict(movies) return movies_as_dict
def add_review(review_text: str, username: str, movie_id: int, rating: int, repo: AbstractRepository): # Check that the movie exists. movie = repo.get_movie_by_index(movie_id) if movie is None: raise NonExistentMovieException # Check that the user exists user = repo.get_user(username) if user is None: raise UnknownUserException # Create review review = make_review(review_text=review_text, user=user, movie=movie, rating=rating) # Update the repository repo.add_review(review)
def search_movie_by_title(title:str, repo:AbstractRepository): movies = repo.search_movie_by_title(title) if len(movies) == 0: raise NoSearchResultsException movies_as_dict = movies_to_dict(movies) return movies_as_dict
def get_reviews_for_movie(movie_id, repo: AbstractRepository): movie = repo.get_movie_by_index(movie_id) if movie is None: raise NonExistentMovieException return reviews_to_dict(movie.reviews)
def get_reviews_for_movie(movie_id, repo: AbstractRepository): article = repo.get_movie(movie_id) if article is None: raise NonExistentMovieException return reviews_to_dict(article.comments)
def add_review(movie_id: int, review_text: str, username: str, repo: AbstractRepository): # Check that the movie exists. movie = repo.get_movie(movie_id) if movie is None: raise NonExistentMovieException user = repo.get_user(username) if user is None: raise UnknownUserException # Create review. review = make_review(review_text, user, movie) # Update the repository. repo.add_review(review)
def get_top_6_movies_by_revenue(repo:AbstractRepository): movies = repo.get_top_6_highest_revenue_movies() if len(movies) == 0: raise NoSearchResultsException movies_as_dict = movies_to_dict(movies) return movies_as_dict
def search_movie_by_actor_fullname(actor_fullname: str, repo: AbstractRepository): movies = repo.get_movies_played_by_an_actor(actor_fullname=actor_fullname) if len(movies) == 0: raise NonExistentActorException movies_as_dict = movies_to_dict(movies) return movies_as_dict
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 search_movie_directed_by_director_fullname(director_fullname: str, repo: AbstractRepository): movies = repo.get_movies_directed_by_a_director( director_fullname=director_fullname) if len(movies) == 0: raise NonExistentDirectorException movies_as_dict = movies_to_dict(movies) return movies_as_dict
def add_review(rate: int, rank: int, review_text: str, username: str, repo: AbstractRepository): # Check that the article exists. movie = repo.get_movie(int(rank)) print(movie) if movie is None: raise NonExistentMovieException user = repo.get_user(username) if user is None: raise UnknownUserException timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S") print(timestamp) # Create comment. review = make_review(review_text, user, movie, timestamp, rate) # Update the repository. repo.add_review(review)
def get_all_genres(repo: AbstractRepository): genres = [] for genre in repo.get_genres(): genres.append(genre) if genres is []: raise NonExistentGenreException return sorted(genres)
def get_all_years(repo: AbstractRepository): years = [] for year in repo.get_years(): years.append(year) if years is []: raise NonExistentYearException return sorted(years, reverse=True)
def get_11_movie(repo: AbstractRepository): movies = [] for rank in range(1, 12): movies.append(repo.get_movie(rank)) if movies is [] or len(movies) != 11: raise NonExistentMovieException return movies
def get_all_movie(condition, repo: AbstractRepository): movies = [] if condition[0] != 'All' and condition[1] != 'All': movies_genre = repo.get_movies_by_genre(condition[0]) movies_year = repo.get_movies_by_year(condition[1]) if len(movies_year) < len(movies_genre): for movie in movies_year: if movie in movies_genre: movies.append(movie) else: for movie in movies_genre: if movie in movies_year: movies.append(movie) elif condition == ['All', 'All']: for rank in range(1, repo.get_number_of_movies() + 1): movies.append(repo.get_movie(int(rank))) else: index = condition.index('All') if index == 0: movies = repo.get_movies_by_year(condition[1]) else: movies = repo.get_movies_by_genre(condition[0]) if movies == []: return 'None' return movies
def get_user(username: str, repo: AbstractRepository): user = repo.get_user(username) if user is None: raise UnknownUserException return user_to_dict(user)
def get_movie_ids_for_genre(genre_name: str, repo: AbstractRepository): movie_ids = repo.get_movie_indexes_for_genre(genre_name) return movie_ids
def get_oldest_movie(repo: AbstractRepository): movie = repo.get_oldest_movie() return movie_to_dict(movie)
def get_latest_year(repo:AbstractRepository): return repo.get_latest_year()