Exemplo n.º 1
0
def register():
    form = RegistrationForm()
    username_not_unique = None

    if form.validate_on_submit():
        # Successful POST, i.e. the username and password have passed validation checking.
        # Use the service layer to attempt to add the new user.
        try:
            services.add_user(form.username.data, form.password.data, repo.repo_instance)

            # All is well, redirect the user to the login page.
            return redirect(url_for('authentication_bp.login'))
        except services.NameNotUniqueException:
            username_not_unique = 'Your username is already taken - please supply another'

    # For a GET or a failed POST request, return the Registration Web page.
    return render_template(
        'authentication/credentials.html',
        title='Register',
        form=form,
        username_error_message=username_not_unique,
        handler_url=url_for('authentication_bp.register'),
        selected_movies=utilities.get_selected_movies(),
        genre_urls=utilities.get_genres_and_urls(),
        actor_urls=utilities.get_actors_and_urls(),
        director_urls=utilities.get_directors_and_urls(),

    )
Exemplo n.º 2
0
def home():
    return render_template(
        'home/home.html',
        genre_urls=utilities.get_genres_and_urls(),
        actor_urls=utilities.get_actors_and_urls(),
        director_urls=utilities.get_directors_and_urls(),
    )
Exemplo n.º 3
0
def comment_on_movie():
    # Obtain the username of the currently logged in user.
    username = session['username']

    # Create form. The form maintains state, e.g. when this method is called with a HTTP GET request and populates
    # the form with an movie id, when subsequently called with a HTTP POST request, the movie id remains in the
    # form.
    form = CommentForm()

    if form.validate_on_submit():
        # Successful POST, i.e. the comment text has passed data validation.
        # Extract the movie id, representing the commented movie, from the form.
        movie_id = int(form.movie_id.data)

        # Use the service layer to store the new comment.
        services.add_comment(movie_id, form.comment.data, username,
                             repo.repo_instance)

        # Retrieve the movie in dict form.
        movie = services.get_movie(movie_id, repo.repo_instance)

        # refresh this webpage
        # to show all the comments of this movie, include the newly created one.
        return redirect(url_for('movies_bp.comment_on_movie', movie=movie_id))

    if request.method == 'GET':
        # Request is a HTTP GET to display the form.
        # Extract the movie id, representing the movie to comment, from a query parameter of the GET request.
        movie_id = int(request.args.get('movie'))

        # Store the movie id in the form.
        form.movie_id.data = movie_id
    else:
        # Request is a HTTP POST where form validation has failed.
        # Extract the movie id of the movie being commented from the form.
        movie_id = int(form.movie_id.data)

    # For a GET or an unsuccessful POST, retrieve the movie to comment in dict form, and return a Web page that allows
    # the user to enter a comment. The generated Web page includes a form object.
    movie = services.get_movie(movie_id, repo.repo_instance)
    return render_template(
        'movies/comment_on_movie.html',
        title='Comment movie',
        movie=movie,
        form=form,
        handler_url=url_for('movies_bp.comment_on_movie'),

        # selected_articles=utilities.get_selected_articles(),
        selected_articles=list(),
        # tag_urls=utilities.get_tags_and_urls()
        tag_urls=list(),
        genre_urls=utilities.get_genres_and_urls(),
        actor_urls=utilities.get_actors_and_urls(),
        director_urls=utilities.get_directors_and_urls(),
    )
Exemplo n.º 4
0
def review_on_movie():
    # Obtain the username of the currently logged in user.
    username = session['username']

    # Create form. The form maintains state, e.g. when this method is called with a HTTP GET request and populates
    # the form with an article id, when subsequently called with a HTTP POST request, the article id remains in the
    # form.
    form = ReviewForm()

    if form.validate_on_submit():
        # Successful POST, i.e. the comment text has passed data validation.
        # Extract the article id, representing the commented article, from the form.
        movie_rank = int(form.movie_rank.data)

        # Use the service layer to store the new comment.
        services.add_review(movie_rank, form.review.data, username,
                            repo.repo_instance, int(form.review2.data))

        # Retrieve the article in dict form.
        movie = services.get_movie(movie_rank, repo.repo_instance)

        # Cause the web browser to display the page of all articles that have the same date as the commented article,
        # and display all comments, including the new comment.
        return redirect(
            url_for('news_bp.movies_by_genre',
                    genre=movie['genre'].genre_name,
                    view_reviews_for=movie_rank))

    if request.method == 'GET':
        # Request is a HTTP GET to display the form.
        # Extract the article id, representing the article to comment, from a query parameter of the GET request.
        movie_rank = int(request.args.get('movie'))

        # Store the article id in the form.
        form.movie_rank.data = movie_rank
    else:
        # Request is a HTTP POST where form validation has failed.
        # Extract the article id of the article being commented from the form.
        movie_rank = int(form.movie_rank.data)

    # For a GET or an unsuccessful POST, retrieve the article to comment in dict form, and return a Web page that allows
    # the user to enter a comment. The generated Web page includes a form object.
    movie = services.get_movie(movie_rank, repo.repo_instance)
    return render_template(
        'news/comment_on_article.html',
        title='Edit article',
        movie=movie,
        form=form,
        handler_url=url_for('news_bp.review_on_movie'),
        selected_movies=utilities.get_selected_movies(),
        genre_urls=utilities.get_genres_and_urls(),
        actor_urls=utilities.get_actors_and_urls(),
        director_urls=utilities.get_directors_and_urls(),
    )
Exemplo n.º 5
0
def login():
    form = LoginForm()
    username_not_recognised = None
    password_does_not_match_username = None

    if form.validate_on_submit():
        # Successful POST, i.e. the username and password have passed validation checking.
        # Use the service layer to lookup the user.
        try:
            user = services.get_user(form.username.data, repo.repo_instance)

            # Authenticate user.
            services.authenticate_user(user['username'], form.password.data,
                                       repo.repo_instance)

            # Initialise session and redirect the user to the home page.
            session.clear()
            session['username'] = user['username']
            return redirect(url_for('home_bp.home'))

        except services.UnknownUserException:
            # Username not known to the system, set a suitable error message.
            username_not_recognised = 'Username not recognised - please supply another'

        except services.AuthenticationException:
            # Authentication failed, set a suitable error message.
            password_does_not_match_username = '******'

    # For a GET or a failed POST, return the Login Web page.
    return render_template(
        'authentication/credentials.html',
        title='Login',
        username_error_message=username_not_recognised,
        password_error_message=password_does_not_match_username,
        form=form,
        selected_movies=utilities.get_selected_movies(),
        genre_urls=utilities.get_genres_and_urls(),
        actor_urls=utilities.get_actors_and_urls(),
        director_urls=utilities.get_directors_and_urls(),
    )
Exemplo n.º 6
0
def movies_by_genre():
    movies_per_page = 3

    # Read query parameters.
    genre_name = request.args.get('genre')

    cursor = request.args.get('cursor')
    movie_to_show_reviews = request.args.get('view_reviews_for')

    if movie_to_show_reviews is None:
        # No view-comments query parameter, so set to a non-existent article id.
        movie_to_show_reviews = -1
    else:
        # Convert article_to_show_comments from string to int.
        movie_to_show_reviews = int(movie_to_show_reviews)

    if cursor is None:
        # No cursor query parameter, so initialise cursor to start at the beginning.
        cursor = 0
    else:
        # Convert cursor from string to int.
        cursor = int(cursor)

    # Retrieve article ids for articles that are tagged with tag_name.
    movie_ranks = services.get_movie_ranks_for_genre(genre_name,
                                                     repo.repo_instance)

    # Retrieve the batch of articles to display on the Web page.
    movies = services.get_movies_by_rank(
        movie_ranks[cursor:cursor + movies_per_page], repo.repo_instance)

    first_movie_url = None
    last_movie_url = None
    next_movie_url = None
    prev_movie_url = None

    if cursor > 0:
        # There are preceding articles, so generate URLs for the 'previous' and 'first' navigation buttons.
        prev_movie_url = url_for('news_bp.movies_by_genre',
                                 genre=genre_name,
                                 cursor=cursor - movies_per_page)
        first_movie_url = url_for('news_bp.movies_by_genre', genre=genre_name)

    if cursor + movies_per_page < len(movie_ranks):
        # There are further articles, so generate URLs for the 'next' and 'last' navigation buttons.
        next_movie_url = url_for('news_bp.movies_by_genre',
                                 genre=genre_name,
                                 cursor=cursor + movies_per_page)

        last_cursor = movies_per_page * int(len(movie_ranks) / movies_per_page)
        if len(movie_ranks) % movies_per_page == 0:
            last_cursor -= movies_per_page
        last_movie_url = url_for('news_bp.movies_by_genre',
                                 genre=genre_name,
                                 cursor=last_cursor)

    # Construct urls for viewing article comments and adding comments.
    for movie in movies:
        movie['view_review_url'] = url_for('news_bp.movies_by_genre',
                                           genre=genre_name,
                                           cursor=cursor,
                                           view_reviews_for=movie['rank'])
        movie['add_review_url'] = url_for('news_bp.review_on_movie',
                                          movie=movie['rank'])
    # Generate the webpage to display the articles.
    return render_template('news/articles.html',
                           title='Movie',
                           movies_title='Movies of ' + genre_name,
                           movies=movies,
                           selected_movies=utilities.get_selected_movies(
                               len(movies) * 2),
                           actor_urls=utilities.get_actors_and_urls(),
                           genre_urls=utilities.get_genres_and_urls(),
                           director_urls=utilities.get_directors_and_urls(),
                           first_movie_url=first_movie_url,
                           last_movie_url=last_movie_url,
                           prev_movie_url=prev_movie_url,
                           next_movie_url=next_movie_url,
                           show_reviews_for_movie=movie_to_show_reviews)
Exemplo n.º 7
0
def movies_by_genre():
    movies_per_page = 3

    # Read query parameters.
    genre_name = request.args.get('genre')
    actor_name = request.args.get('actor')
    director_name = request.args.get('director')
    # pagination cursor
    cursor = request.args.get('cursor')
    # comment
    movie_to_show_comments = request.args.get('view_comments_for')

    if movie_to_show_comments is None:
        # No view-comments query parameter, so set to a non-existent movie id.
        movie_to_show_comments = -1
    else:
        # Convert movie_to_show_comments  from string to int.
        movie_to_show_comments = int(movie_to_show_comments)

    if cursor is None:
        # No cursor query parameter, so initialise cursor to start at the beginning.
        cursor = 0
    else:
        # Convert cursor from string to int.
        cursor = int(cursor)

    # print(genre_name)
    # print(actor_name)
    # print(director_name)
    if genre_name:
        genre_name = genre_name.strip()
    else:
        genre_name = ''
    if actor_name:
        actor_name = actor_name.strip()
    else:
        actor_name = ''
    if director_name:
        director_name = director_name.strip()
    else:
        director_name = ''

    movie_ids_all = services.get_movie_ids_all(repo.repo_instance)
    movie_ids = movie_ids_all

    # https://www.kite.com/python/answers/how-to-find-the-intersection-of-two-lists-in-python
    # list1 = [1, 2, 3]
    # list2 = [1, 3, 5]
    # intersection_set = set.intersection(set(list1), set(list2))
    # find intersection of list1 and list2
    # intersection_list = list(intersection_set)
    # print(intersection_list)
    #     OUTPUT
    #     [1, 3]

    # Retrieve movie ids for movies that are genre with genre_name.
    if genre_name:
        genre_movie_ids = services.get_movie_ids_for_genre(
            genre_name, repo.repo_instance)
        movie_ids = list(set.intersection(set(movie_ids),
                                          set(genre_movie_ids)))

    # Retrieve movie ids for movies that are acted with actor_name.
    if actor_name:
        actor_movie_ids = services.get_movie_ids_for_actor(
            actor_name, repo.repo_instance)
        movie_ids = list(set.intersection(set(movie_ids),
                                          set(actor_movie_ids)))

    # Retrieve movie ids for movies that are directed with director_name.
    if director_name:
        director_movie_ids = services.get_movie_ids_for_director(
            director_name, repo.repo_instance)
        movie_ids = list(
            set.intersection(set(movie_ids), set(director_movie_ids)))

    movie_ids.sort()
    # print(movie_ids)

    # Retrieve the batch of movies to display on the Web page.
    movies = services.get_movies_by_id(
        movie_ids[cursor:cursor + movies_per_page], repo.repo_instance)

    first_article_url = None
    last_article_url = None
    next_article_url = None
    prev_article_url = None

    if cursor > 0:
        # There are preceding movies, so generate URLs for the 'previous' and 'first' navigation buttons.
        prev_article_url = url_for('movies_bp.movies_by_genre',
                                   genre=genre_name,
                                   actor=actor_name,
                                   director=director_name,
                                   cursor=cursor - movies_per_page)
        first_article_url = url_for('movies_bp.movies_by_genre',
                                    genre=genre_name,
                                    actor=actor_name,
                                    director=director_name)

    if cursor + movies_per_page < len(movie_ids):
        # There are further movies, so generate URLs for the 'next' and 'last' navigation buttons.
        next_article_url = url_for('movies_bp.movies_by_genre',
                                   genre=genre_name,
                                   actor=actor_name,
                                   director=director_name,
                                   cursor=cursor + movies_per_page)

        last_cursor = movies_per_page * int(len(movie_ids) / movies_per_page)
        if len(movie_ids) % movies_per_page == 0:
            last_cursor -= movies_per_page
        last_article_url = url_for('movies_bp.movies_by_genre',
                                   genre=genre_name,
                                   actor=actor_name,
                                   director=director_name,
                                   cursor=last_cursor)

    # Construct urls for viewing movie comments and adding comments.
    for movie in movies:
        movie['view_comment_url'] = url_for('movies_bp.movies_by_genre',
                                            genre=genre_name,
                                            actor=actor_name,
                                            director=director_name,
                                            cursor=cursor,
                                            view_comments_for=movie['id'])
        movie['add_comment_url'] = url_for('movies_bp.comment_on_movie',
                                           movie=movie['id'])

    # Generate the webpage to display the articles.
    return render_template('movies/movies.html',
                           movies=movies,
                           genre_name=genre_name,
                           actor_name=actor_name,
                           director_name=director_name,
                           genre_urls=utilities.get_genres_and_urls(),
                           actor_urls=utilities.get_actors_and_urls(),
                           director_urls=utilities.get_directors_and_urls(),
                           first_article_url=first_article_url,
                           last_article_url=last_article_url,
                           prev_article_url=prev_article_url,
                           next_article_url=next_article_url,
                           show_comments_for_movie=movie_to_show_comments)