def add_director_review(user_name: str, director_name: str, review_text: str,
repo: AbstractRepository):
director = repo.get_director(director_name)
user = repo.get_user(user_name)
if user is None:
raise UnknownUserException
review = make_director_review(user, director, review_text)
repo.add_director_review(review)
def add_user(user_name, password, repo: AbstractRepository):
user = repo.get_user(user_name.lower())
if user is not None:
raise NameNotUniqueException
password_hash = generate_password_hash(password)
user = User(user_name, password_hash)
repo.add_user(user)
def get_search_info(name, repo: AbstractRepository):
movies = repo.get_movies_for_actor(name)
movies += repo.get_movies(name)
movies += repo.get_movies_for_genre(name)
movies += repo.get_movies_for_director(name)
movies = set(movies)
movies = list(movies)
movies.sort(key=lambda movie: movie.rating, reverse=True)
return movies_to_dict(movies)
def get_random_movies(quantity, repo: AbstractRepository):
movie_count = repo.get_number_of_movie()
if quantity >= movie_count:
quantity = movie_count - 1
random_ids = random.sample(range(1, movie_count), quantity)
movies = repo.get_movies_by_id(random_ids)
return movies_to_dict(movies)
def remove_from_watch_list(movie_id, username, repo: AbstractRepository):
# Check that the movie exists.
movie = repo.get_movie(int(movie_id))
if movie is None:
raise NonExistentMovieException
user = repo.get_user(username)
if user is None:
raise UnknownUserException
repo.remove_from_watch_list(user, movie)
def get_movies_in_rank(quantity, repo: AbstractRepository):
movie_size = repo.get_number_of_movies()
if quantity >= movie_size:
quantity = movie_size - 1
rank_list = [i for i in range(1, quantity + 1)]
movies = repo.get_movies_by_rank(rank_list)
return movies_to_dict(movies)
def add_to_watch_list(movie_id: int, username: str, repo: AbstractRepository):
# Check that the movie exists.
movie = repo.get_movie(int(movie_id))
if movie is None:
raise NonExistentMovieException
user = repo.get_user(username)
if user is None:
raise UnknownUserException
if movie not in user.watch_list:
repo.add_to_watch_list(user, movie)
def get_random_movies(quantity, repo: AbstractRepository):
movie_count = repo.get_number_of_movies()
if quantity >= movie_count:
# Reduce the quantity of ids to generate if the repository has an insufficient number of articles.
quantity = movie_count - 1
# Pick distinct and random articles.
random_ids = random.sample(range(1, movie_count), quantity)
movies = repo.get_movies_by_id(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_movies_by_release_year(year, repo: AbstractRepository):
movies = repo.get_movies_by_release_year(target_year=year)
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 = movies_to_dict(movies)
return movies, prev_year, next_year
def get_movies_by_year(year, repo: AbstractRepository):
movies = repo.get_movies_by_year(target_year=year)
movies_dto = list()
prev_year = next_year = None
if len(movies) > 0:
prev_year = repo.get_year_of_previous_movie(movies[0]) #可能要改
next_year = repo.get_year_of_next_movie(movies[0])
movies_dto = movies_to_dict(movies)
return movies_dto, prev_year, next_year
def add_review(user_name: str, movie_id: int, review_text: str,
repo: AbstractRepository):
movie = repo.get_movie_by_id(int(movie_id))
if movie is None:
raise NonExistentMovieException
user = repo.get_user(user_name)
if user is None:
raise UnknownUserException
review = make_review(user, movie, review_text)
repo.add_review(review)
def add_comment(movie_id: int, comment_text: str, username: str, repo: AbstractRepository):
# Check that the movie exists.
movie = repo.get_movie(int(movie_id))
if movie is None:
raise NonExistentMovieException
user = repo.get_user(username)
if user is None:
raise UnknownUserException
# Create comment.
comment = make_review(comment_text, user, movie)
# Update the repository.
repo.add_comment(comment)
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 = make_review(review_text, user, movie, rating)
# Update the repository.
repo.add_review(review)
def get_reviews_for_movie(movie_id, repo: AbstractRepository):
movie = repo.get_movie_by_id(movie_id)
if movie is None:
raise NonExistentException
return reviews_to_dict(movie.reviews)
def get_movies_by_id(id_list, repo: AbstractRepository):
movies = repo.get_movies_by_id(id_list)
# Convert Movies to dictionary form
movies_as_dict = movies_to_dict(movies)
return movies_as_dict
def get_movie(movie_id: int, repo: AbstractRepository):
movie = repo.get_movie_by_id(movie_id)
if movie is None:
raise NonExistentException
return movie_to_dict(movie)
def search_movie_by_title(title:str, repo:AbstractRepository):
movies = repo.search_movie_by_title(title)
if len(movies) == 0:
raise NonExistentException
movies_as_dict = movies_to_dict(movies)
return movies_as_dict
def get_movies_by_name(name, repo: AbstractRepository):
movie = repo.get_movies_by_name(name)
# if len(movie) == 0:
# raise NonExistentMovieException
# else:
# return movies_to_dict(movie)
return movies_to_dict(movie)
def get_movie(rank: int, repo: AbstractRepository):
movie = repo.get_movie(rank)
if movie is None:
raise NonExistentMovieException
return movie_to_dict(movie)
def get_comments_for_article(article_id, repo: AbstractRepository):
article = repo.get_article(article_id)
if article is None:
raise NonExistentArticleException
return comments_to_dict(article.comments)
def get_articles_by_id(id_list, repo: AbstractRepository):
articles = repo.get_articles_by_id(id_list)
# Convert Articles to dictionary form.
articles_as_dict = articles_to_dict(articles)
return articles_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_id(movie_id)
if movie is None:
raise NonExistentException
# 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 get_articles_by_date(date, repo: AbstractRepository):
# Returns articles for the target date (empty if no matches), the date of the previous article (might be null), the date of the next article (might be null)
articles = repo.get_articles_by_date(target_date=date)
articles_dto = list()
prev_date = next_date = None
if len(articles) > 0:
prev_date = repo.get_date_of_previous_article(articles[0])
next_date = repo.get_date_of_next_article(articles[0])
# Convert Articles to dictionary form.
articles_dto = articles_to_dict(articles)
return articles_dto, prev_date, next_date
def get_article(article_id: int, repo: AbstractRepository):
article = repo.get_article(article_id)
if article is None:
raise NonExistentArticleException
return article_to_dict(article)
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 get_movies_by_year(year, repo: AbstractRepository):
# Returns Movies for the target year (empty if no matches), the year of the previous movie (might be null),
# the date of the next movie (might be null)
movies = repo.get_movies_by_year(target_year=int(year))
movies.sort(key=lambda movie: movie.rating, reverse=True)
movies_dto = list()
prev_year = next_year = None
if len(movies) > 0:
prev_year = repo.get_year_of_previous_movie(movies[0])
next_year = repo.get_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 search_movie_by_actor_fullname(actor_fullname: str, repo: AbstractRepository):
movies = repo.get_movies_by_actor(actor_fullname=actor_fullname)
if len(movies) == 0:
raise NonExistentException
movies_as_dict = movies_to_dict(movies)
return movies_as_dict
def get_movies_by_year(year, repo: AbstractRepository):
# Returns movies for the target year (empty if no matches), the date of the previous article (might be null), the date of the next article (might be null)
movies = repo.get_movie_with_given_year(year)
movies_dto = list()
#prev_date = next_date = None
if len(movies) > 0:
#prev_date = repo.get_date_of_previous_article(articles[0])
#next_date = repo.get_date_of_next_article(articles[0])
# Convert Articles to dictionary form.
movies_name = list()
for movie_rank in movies:
movies_name.append(repo.get_movie(movie_rank))
movies_dto = movies_to_dict(movies_name)
return movies_dto
def get_article_ids_for_tag(tag_name, repo: AbstractRepository):
article_ids = repo.get_article_ids_for_tag(tag_name)
return article_ids
