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