def add_review(title: str, release_year: int, username: str, review_text: str, rating: int, repo: AbstractRepository):
movie = repo.get_movie(title=title, release_year=release_year)
if movie is None:
raise NonExistentMovieException
user = repo.get_user(username=username)
if user is None:
raise UnknownUserException
review = Review(movie, review_text, rating)
user.add_review(review)
repo.add_review(review)
def get_movies_by_title(title: str, repo: AbstractRepository):
movies = repo.get_movies_by_title(title)
movies_dto = list()
prev_title = None
next_title = None
if len(movies) > 0:
prev_title = repo.get_title_of_previous_movie(movies[0])
next_title = repo.get_title_of_next_movie(movies[0])
movies_dto = movies_to_dict(movies)
return movies_dto, prev_title, next_title
def add_user(username: str, password: str, repo: AbstractRepository):
# check that given username is available
user = repo.get_user(username)
if user is not None:
raise NameNotUniqueException
# if available generate password hash and store new user with hash
password_hash = generate_password_hash(password)
user = User(username, password_hash)
repo.add_user(user)
def set_rating(movie_id: int, rating: int, username: str,
repo: AbstractRepository):
user = repo.get_user(username)
if user is None:
user = User('Guest account', 'defaultpass')
movie = repo.get_movie(movie_id)
if movie is None:
raise NonExistentMovieException
repo.set_rating(rating, user, movie)
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(username: str, password: str, repo: AbstractRepository):
# Check that the username is not taken
user = repo.get_user(username)
if user is not None:
raise NameNotUniqueException
# Encrypt password
password_hash = generate_password_hash(password)
# Create and store the new User with encrypted password
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 the quantity of ids to generate if the repository has an 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_review(movie_title: str, review_text: str, username: str, rating: int,
repo: AbstractRepository):
movie = repo.get_movie(movie_title)
if movie is None:
raise NonExistentMovieException
user = repo.get_user(username)
if user is None:
raise UnknownUserException
review = make_review(review_text, user, movie, rating)
repo.add_review(review)
def get_movies_by_letter(letter, repo: AbstractRepository):
# Returns movies from a given letter (returns None if there are no matches), the previous letter and the next letter
movies = repo.get_movies_by_letter(letter)
movies_dict = list()
prev_letter = None
next_letter = None
if len(movies) > 0:
movies_dict = movies_to_dict(movies)
prev_letter = repo.get_letter_of_previous_movie(movies[0])
next_letter = repo.get_letter_of_next_movie(movies[0])
return movies_dict, prev_letter, next_letter
def add_review(movie_id: int, review_text: str, rating, username: str, repo: AbstractRepository):
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, rating)
# Update Repo
repo.add_review(review)
def get_random_movies(quantity, repo: AbstractRepository):
movie_count = repo.get_number_of_movies()
if quantity >= movie_count:
quantity = movie_count - 1
# Pick distinct and random movies.
random_indexes = random.sample(range(0, movie_count - 1), quantity)
random_movies = list()
movies = repo.get_movies()
for i in random_indexes:
random_movies.append(movies[i])
return movies_to_dict(random_movies)
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 movies.
quantity = movie_count - 1
# Pick distinct and random movies.
random_indices = random.sample(range(1, movie_count), quantity)
random_movies = []
for index in random_indices:
random_movies.append(repo.get_movies()[index])
return random_movies
def add_review(movie_id: int, review_text: str, rating: int, username: str, repo: AbstractRepository):
# Check that the movie exists.
movie = repo.get_movie_by_id(movie_id)
if movie is None:
raise NonExistentMovieException
user = repo.get_user(username)
if user is None:
raise UnknownUserException
# Create review.
review = Review(username, movie, review_text, rating)
# Update the repository.
user.add_review(review)
def get_movie(movie_rank: int, repo: AbstractRepository):
movie = repo.get_movie(movie_rank)
if movie is None:
raise NonExistentMovieException
return movie_to_dict(movie, repo)
def get_movies(repo: AbstractRepository):
movies = repo.get_movies()
if movies is None:
pass
return movies
def get_movies_by_rank(rank_list, repo: AbstractRepository):
movies = repo.get_movies_by_rank(rank_list)
# Convert Movies to dictionary form.
movies_as_dict = movies_to_dict(movies, repo)
return movies_as_dict
def get_user(repo: AbstractRepository, username=None):
user = None
try:
user = repo.get_user(username)
except:
pass
return user
def get_comments_for_movie(movie_rank, repo: AbstractRepository):
movie = repo.get_movie(movie_rank)
if movie is None:
raise NonExistentMovieException
return comments_to_dict(movie.comments)
def get_movie(movie_title: str, repo: AbstractRepository):
movie = repo.get_movie(movie_title)
if movie is None:
raise NonExistentMovieException
return movie_to_dict(movie)
def add_comment(movie_rank: int, comment_text: str, 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:
user = User("Guest account", "Abcd1234")
# Create comment.
comment = make_comment(comment_text, user, movie)
# Update the repository.
repo.add_comment(comment)
def get_reviews_for_movie(movie: Movie, repo: AbstractRepository):
reviews = repo.get_reviews()
reviews_for_movie = list()
for review in reviews:
if review.movie == movie:
reviews_for_movie.append(review)
return reviews_to_dict(reviews_for_movie, repo)
def get_reviews_for_movie(movie_id, repo: AbstractRepository):
movie = repo.get_movie(movie_id)
if movie is None:
raise NonExistentMovieException
return reviews_to_dict(movie.reviews)
def get_movies_by_date(date, repo: AbstractRepository):
# Returns movies for the target date (empty if no matches), the date of the previous movie (might be null), the date of the next movie (might be null)
movies = repo.get_movies_by_date(target_date=date)
movies_dto = list()
prev_date = next_date = None
if len(movies) > 0:
prev_date = repo.get_date_of_previous_movie(movies[0])
next_date = repo.get_date_of_next_movie(movies[0])
# Convert Movies to dictionary form.
movies_dto = movies_to_dict(movies)
return movies_dto, prev_date, next_date
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_watchlist(repo: AbstractRepository):
watchlist = None
if 'username' in session:
username = session['username']
user = repo.get_user(username)
watchlist = user.watchlist
watchlist = movies_to_dict(watchlist)
return watchlist
def genre_to_dict(genre: Genre, repo: AbstractRepository):
genre_dict = {
'name':
genre,
'genre_asso_movies':
[movie.rank for movie in repo.get_movies() if genre in movie.genres]
}
return genre_dict
def get_movie(movie_id: int, repo: AbstractRepository):
try:
movie = repo.get_movie(movie_id)
except:
raise NonExistentMovieException
if movie is None:
raise NonExistentMovieException
return movie_to_dict(movie)
def get_genre_recommendation(repo: AbstractRepository, num_of_recommendations: int, user):
genre_movies = []
genre_recommendations = []
if len(user.watched_movies) > 0:
genre = get_random_watched_movie(user)['genres'][0]
for movie in repo.get_movies():
if movie.genres[0] == genre:
genre_movies.append(movie)
for num in range(num_of_recommendations):
genre_recommendations.append(genre_movies[random.randrange(len(genre_movies))])
return genre_recommendations
def get_director_recommendation(repo: AbstractRepository, num_of_recommendations: int, user):
director_movies = []
director_recommendations = []
if len(user.watched_movies) > 0:
director = get_random_watched_movie(user)['director']
for movie in repo.get_movies():
if movie.director == director:
director_movies.append(movie)
for num in range(num_of_recommendations):
director_recommendations.append(director_movies[random.randrange(len(director_movies))])
return director_recommendations
def review_to_dict(review: Review, repo: AbstractRepository):
users = repo.get_users()
target_user = None
for user in users:
if review in user.reviews:
target_user = user
break
if target_user is not None and type(review) is Review:
review_dict = {
'movie_title': review.movie.title,
'movie_release_year': review.movie.release_year,
'user': target_user.user_name,
'review_text': review.review_text,
'rating': review.rating,
'timestamp': review.timestamp
}
return review_dict
return None
