def get_random_movies(quantity, repo: AbstractRepository): movie_cout = repo.get_number_of_movies() if quantity >= movie_cout: quantity = movie_cout - 1 random_ids = random.sample(range(1, movie_cout), quantity) movies = repo.get_movies_by_id(random_ids) return movies_to_dict(movies)
def get_sorted_movies_by_year(year, repo: AbstractRepository): movies = repo.get_sorted_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_user(username: str, password: str, repo: AbstractRepository): user = repo.get_user(username) if user is not None: raise NameNotUniqueException password_hash = generate_password_hash(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_ids = range(1, movie_count) movies = repo.get_movies_by_id(random_ids) return movies_to_dict(movies)
def get_random_articles(quantity, repo: AbstractRepository): article_count = repo.get_number_of_articles() if quantity >= article_count: # Reduce the quantity of ids to generate if the repository has an insufficient number of articles. quantity = article_count - 1 # Pick distinct and random articles. random_ids = random.sample(range(1, article_count), quantity) articles = repo.get_articles_by_id(random_ids) return articles_to_dict(articles)
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_review(movie_id: int, review_text: str, username: str, rating: int, repo: AbstractRepository): movie = repo.get_movie(movie_id) if movie is None: raise NonExistentArticleException user = repo.get_user(username) if user is None: raise UnknownUserException review = Review(movie, review_text, user, rating) review.movie = movie movie.add_review(review) user.add_review(review) repo.add_review(review)
def add_comment(title: str, comment_text: str, username: str, repo: AbstractRepository): # Check that the article exists. movie = repo.get_movies_by_title(title) if movie is None: raise NonExistentArticleException user = repo.get_user(username) if user is None: raise UnknownUserException # Create comment. comment = make_review(movie, comment_text) # Update the repository. repo.add_review(comment)
def add_comment(article_id: int, comment_text: str, username: str, repo: AbstractRepository): # Check that the article exists. article = repo.get_article(article_id) if article is None: raise NonExistentArticleException user = repo.get_user(username) if user is None: raise UnknownUserException # Create comment. comment = make_comment(comment_text, user, article) # Update the repository. repo.add_comment(comment)
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_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 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_article(article_id: int, repo: AbstractRepository): article = repo.get_article(article_id) if article is None: raise NonExistentArticleException return article_to_dict(article)
def get_movie(title: str, repo: AbstractRepository): movie = repo.get_movies_by_title(title) if movie is None: raise NonExistentArticleException return movie_to_dict(movie)
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_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_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_rank(rank_list, repo: AbstractRepository): movies = repo.get_movies_by_rank(rank_list) # Convert Articles to dictionary form. movies_as_dict = movies_to_dict(movies) return movies_as_dict
def get_movie(movie_rank: int, repo: AbstractRepository): movie = repo.get_movie(movie_rank) if movie is None: raise NonExistentArticleException return movie_to_dict(movie)
def get_movie(movie_id: int, repo: AbstractRepository): movie = repo.get_movie(movie_id) if movie is None: raise NonExistentMovieException return movie_to_dict(movie)
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 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_actor_names(repo: AbstractRepository): actors = repo.get_actors() actor_names = [actor.actor_full_name for actor in actors] return actor_names
def get_entire_movies(repo: AbstractRepository): movies = repo.get_movie_list() return movies
def get_entire_movies_cut(list1, repo: AbstractRepository): movies = repo.get_movie_list_cut(list1) movies_as_dict = movies_to_dict(movies) return movies_as_dict
def get_movie_ids_for_genre(genre_name, repo: AbstractRepository): movie_ids = repo.get_movie_ids_for_genre(genre_name) return movie_ids
def get_genre_names(repo: AbstractRepository): genres = repo.get_genres() genre_names = [genre.genre_name for genre in genres] return genre_names
def get_last_movie(repo: AbstractRepository): movie = repo.get_last_movie() return movie_to_dict(movie)
def get_director_names(repo: AbstractRepository): directors = repo.get_directors() director_names = [director.director_full_name for director in directors] return director_names
def get_tag_names(repo: AbstractRepository): tags = repo.get_tags() tag_names = [tag.tag_name for tag in tags] return tag_names