Example #1
0
def reviews_index():
    if 'page' in flask.request.args:
        page = int(flask.request.args['page'])
    else:
        page = 1
    if page <= 0:
        flask.abort(404)

    with easypg.cursor() as cur:
        total_pages = reviews.get_total_pages(cur)

    with easypg.cursor() as cur:
        review_info = reviews.get_all_reviews(cur, page)

    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None

    if page == total_pages:
        nextPage = None
    else:
        nextPage = page + 1

    return flask.render_template('review_list.html',
                                 reviews=review_info,
                                 page=page,
                                 totalPages=total_pages,
                                 nextPage=nextPage,
                                 prevPage=prevPage)
Example #2
0
def add_review(bid):
    errors = []
    if flask.request.method == 'POST':
        app.logger.info('Received new data for review from user_id %s: %s',
                        flask.ext.login.current_user.id, flask.request.form)
        with easypg.cursor() as cur:
            entry_status, messages, review_id = reviews.add_review(
                cur, bid, flask.ext.login.current_user.id, flask.request.form)
            app.logger.info("Review submitted %s - %s - %s", entry_status,
                            messages, review_id)
            if entry_status:
                for message in messages:
                    flask.flash(message)
                return flask.redirect(
                    flask.request.args.get("next")
                    or flask.url_for("display_review", rid=review_id))
            else:
                for message in messages:
                    errors.append(message)
    with easypg.cursor() as cur:
        book_info = books.get_book(cur, bid, flask.ext.login.current_user.id)
        # print book_info['user_rating']
    if 'next' in flask.request.args:
        next = flask.request.args['next']
    else:
        next = flask.url_for("reviews_index")

    return flask.render_template("review_add_form.html",
                                 book_info=book_info,
                                 error=errors,
                                 next=next)
Example #3
0
def lists_index():

    if "page" in flask.request.args:
        page = int(flask.request.args["page"])
    else:
        page = 1
    if page <= 0:
        flask.abort(404)

    with easypg.cursor() as cur:
        total_pages = lists.get_total_pages(cur)

    with easypg.cursor() as cur:
        if flask.ext.login.current_user.is_authenticated():
            list_info = lists.get_all_lists(cur, page, flask.session["user_id"])
        else:
            list_info = lists.get_all_lists(cur, page, None)

    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None

    if page == total_pages:
        nextPage = None
    else:
        nextPage = page + 1

    return flask.render_template(
        "lists_list.html", lists=list_info, page=page, totalPages=total_pages, nextPage=nextPage, prevPage=prevPage
    )
Example #4
0
def add_review(bid):
    errors = []
    if flask.request.method == "POST":
        app.logger.info(
            "Received new data for review from user_id %s: %s", flask.ext.login.current_user.id, flask.request.form
        )
        with easypg.cursor() as cur:
            entry_status, messages, review_id = reviews.add_review(
                cur, bid, flask.ext.login.current_user.id, flask.request.form
            )
            app.logger.info("Review submitted %s - %s - %s", entry_status, messages, review_id)
            if entry_status:
                for message in messages:
                    flask.flash(message)
                return flask.redirect(flask.request.args.get("next") or flask.url_for("display_review", rid=review_id))
            else:
                for message in messages:
                    errors.append(message)
    with easypg.cursor() as cur:
        book_info = books.get_book(cur, bid, flask.ext.login.current_user.id)
        # print book_info['user_rating']
    if "next" in flask.request.args:
        next = flask.request.args["next"]
    else:
        next = flask.url_for("reviews_index")

    return flask.render_template("review_add_form.html", book_info=book_info, error=errors, next=next)
Example #5
0
def lists_index():

    if 'page' in flask.request.args:
        page = int(flask.request.args['page'])
    else:
        page = 1
    if page <= 0:
        flask.abort(404)

    with easypg.cursor() as cur:
        total_pages = lists.get_total_pages(cur)

    with easypg.cursor() as cur:
        if flask.ext.login.current_user.is_authenticated():
            list_info = lists.get_all_lists(cur, page,
                                            flask.session['user_id'])
        else:
            list_info = lists.get_all_lists(cur, page, None)

    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None

    if page == total_pages:
        nextPage = None
    else:
        nextPage = page + 1

    return flask.render_template('lists_list.html',
                                 lists=list_info,
                                 page=page,
                                 totalPages=total_pages,
                                 nextPage=nextPage,
                                 prevPage=prevPage)
Example #6
0
def edit_book(bid):
    errors = []
    if flask.request.method == 'POST':
        with easypg.cursor() as cur:
            edit_status, messages = books.edit_book(cur, bid,
                                                    flask.request.form)
            if edit_status:
                for message in messages:
                    flask.flash(message)
                return flask.redirect(
                    flask.request.args.get("next")
                    or flask.url_for("display_book", bid=bid))
            else:
                for message in messages:
                    errors.append(message)

    if 'next' in flask.request.args:
        next = flask.request.args['next']
    else:
        next = flask.url_for("display_book", bid=bid)
    with easypg.cursor() as cur:
        book_info = books.get_book(cur, bid)
    return flask.render_template("book_edit_form.html",
                                 book_info=book_info,
                                 error=errors,
                                 next=next)
Example #7
0
def add_review(bid, uid):
    uid = flask.session["user_id"]
    with easypg.cursor() as cur:
        poster = user.get_user_login(cur, uid)
    ts = time.time()
    st = datetime.datetime.fromtimestamp(ts).strftime('%Y-%m-%d %H:%M:%S')

    text = flask.request.form['review']
    app.logger.info('got review from %s: %s', poster, text)
    with easypg.cursor() as cur:
        review.add_review(cur, text, bid, st, uid, poster)

    return flask.redirect('/books/' + bid)
Example #8
0
def print_followees(user_id):
    if request.method == "GET":
        if 'page' in request.args:
            page = int(request.args['page'])
        else:
            page = 1
        if page <= 0:
            abort(404)

        with easypg.cursor() as cur:
            followees = follows.get_followees(cur, page, user_id)
            total_pages = follows.get_followee_pg_cnt(cur, user_id)
            return render_template('followees.html',
                                   follow=followees,
                                   page=page,
                                   total_pages=total_pages,
                                   uid=user_id)

        if page > 1:
            prevPage = page - 1
        else:
            prevPage = None
        if page < total_pages:
            nextPage = page + 1
        else:
            nextPage = None
Example #9
0
def print_followers(uid):
    if 'page' in request.args:
        page = int(request.args['page'])
    else:
        page = 1
    if page <= 0:
        abort(404)

    id = session['username']
    with easypg.cursor() as cur:
        followers = follows.get_followers(cur, page, id)
        total_pages = follows.get_follower_pg_cnt(cur, id)
        return render_template('followers.html',
                               follow=followers,
                               page=page,
                               total_pages=total_pages,
                               user=id)
    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None
    if page < total_pages:
        nextPage = page + 1
    else:
        nextPage = None
Example #10
0
def get_search_results():
    if 'q' in request.args:
        query = request.args['q']
    if 'dropdown' in request.args:
        type = request.args['dropdown']
    else:
        abort(400)

    books = None
    authors = None
    categories = None
    users = None

    with easypg.cursor() as cur:
        if type == "Book":
            books = queries.search_titles(cur, query)
        if type == "Author":
            authors = queries.search_authors(cur, query)
        if type == "Categories":
            categories = queries.search_categories(cur, query)
        if type == "User":
            users = queries.search_users(cur, query)

    return render_template('search_results.html',
                           query=query,
                           books=books,
                           users=users,
                           authors=authors,
                           categories=categories)
Example #11
0
def login():
    with easypg.cursor() as cur:
        num_users = user.get_user_count(cur)
        num_friends = friends.count_num_friends(cur)
    return flask.render_template('login.html',
                                 num_users=num_users,
                                 num_friends=num_friends)
Example #12
0
def dlt_review(uid, rid):
    with easypg.cursor() as cur:
        f = request.form
        for key in f.keys():
            remove_review = f.getlist(key)[0]
        reviews.delete_review(cur, remove_review)
    return redirect('/users/' + uid + '/reviews')
Example #13
0
def find_books_with_tag(tag):
    uid = flask.session["user_id"]
    if 'page' in flask.request.args:
        page = int(flask.request.args['page'])
    else:
        page = 1
    if page <= 0:
        flask.abort(404)

    with easypg.cursor() as cur:
        book_list = books.get_all_books_with_tag(cur, tag, page)
        login = user.get_user_login(cur, uid)
    total = book_list.__len__()

    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None
    nextPage = page + 1

    extraPage = 0
    remainder = total % 50
    if remainder != 0:
        extraPage = 1
    maxPages = int(total / 50) + extraPage

    return flask.render_template('tagBooks.html',
                                 login=login,
                                 book_list=book_list,
                                 tag_name=tag,
                                 total=total)
Example #14
0
def list_books_by_pub(pub_name):
    uid = flask.session["user_id"]
    if 'page' in flask.request.args:
        page = int(flask.request.args['page'])
    else:
        page = 1
    if page <= 0:
        flask.abort(404)

    with easypg.cursor() as cur:
        pub_book_list = books.get_all_books_with_publisher(cur, pub_name, page)
        login = user.get_user_login(cur, uid)
    total = pub_book_list.__len__()

    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None
    nextPage = page + 1

    extraPage = 0
    remainder = total % 50
    if remainder != 0:
        extraPage = 1
    maxPages = int(total / 50) + extraPage

    return flask.render_template('pubBooks.html',
                                 login=login,
                                 pub_book_list=pub_book_list,
                                 publisher=pub_name,
                                 total=total)
Example #15
0
def get_search_results():
    if 'q' in flask.request.args:
        query = flask.request.args['q']
    else:
        flask.abort(400)

    if 'page' in flask.request.args:
        page = int(flask.request.args['page'])
    else:
        page = 1
    if page <= 0:
        flask.abort(404)

    with easypg.cursor() as cur:
        results, total = search.search_books(cur, query, page)

    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None
    nextPage = page + 1

    extraPage = 0
    remainder = total % 50
    if remainder != 0:
        extraPage = 1
    maxPages = int(total / 50) + extraPage
    return flask.render_template('search_results.html',
                                 query=query,
                                 books=results,
                                 total=total,
                                 resultsPages=maxPages,
                                 prevPage=prevPage,
                                 nextPage=nextPage,
                                 page=page)
Example #16
0
def profile_points(profile_id):
    uid = flask.session['user_id']
    with easypg.cursor() as cur:
        login = user.get_user_login(cur, uid)
        profile_login = user.get_user_login(cur, profile_id)
        friend_points = friends.num_friends_targeting_user(cur, profile_id)
        quote_points = 0
        #quote_points = quote.get_quote_points_for_user(cur, profile_id)
        review_points = review.get_num_reviews_for_user(cur, profile_id)
        book_points = books.num_unique_books_read(cur, profile_id)
        comment_points = comments.get_comment_points_for_user(cur, profile_id)
    total_points = 0
    total_points = total_points + friend_points
    total_points = total_points + review_points
    total_points = total_points + book_points
    #total_points = total_points + quote_points
    total_points = total_points + comment_points

    return flask.render_template('points_page.html',
                                 login=login,
                                 profile_id=profile_id,
                                 total_points=total_points,
                                 friend_points=friend_points,
                                 book_points=book_points,
                                 profile_login=profile_login,
                                 quote_points=quote_points,
                                 review_points=review_points,
                                 comment_points=comment_points)
Example #17
0
def view_particular_list(ulid):
    viewer_id = flask.session['user_id']
    with easypg.cursor() as cur:
        login = user.get_user_login(cur, viewer_id)
        list_owner_id = lists.get_owner_for_list(cur, ulid)
        list_owner_login = user.get_user_login(cur, list_owner_id)
        list_info = lists.get_books_in_list(cur, ulid)
        num_books_in_list = list_info.__len__()
        list_name = lists.get_list_name(cur, ulid)
        comment_info = comments.get_comments_for_list(cur, ulid)

        if login == list_owner_login:
            same_user = True
        else:
            same_user = False

    return flask.render_template('list.html',
                                 login=login,
                                 list_owner_login=list_owner_login,
                                 list_owner_id=list_owner_id,
                                 num_books_in_list=num_books_in_list,
                                 list_info=list_info,
                                 list_name=list_name,
                                 same_user=same_user,
                                 ulid=ulid,
                                 comment_info=comment_info)
Example #18
0
def unfollow_from_user_page(uid):
    f = request.form
    for key in f.keys():
        remove_follower = f.getlist(key)[0]
    with easypg.cursor() as cur:
        follows.unfollow(cur, session['username'], remove_follower)
    return redirect('/users/' + uid)
Example #19
0
def get_frnd_actvty(uid):
    with easypg.cursor() as cur:
        user_id = queries.get_user_id(cur, uid)
        activity_info = activity.get_friend_activity(cur, user_id)
    return render_template('activity_list.html',
                           activity_info=activity_info,
                           uid=uid)
Example #20
0
def account_details():
    uid = flask.session['user_id']
    with easypg.cursor() as cur:
        user_info = user.get_user_info(cur, uid)

        user_list = lists.get_user_list_info(cur, uid)
        num_lists = lists.get_num_lists_for_user(cur, uid)
        books_read = books.get_books_read(cur, uid)
        num_books_read = books.num_books_read(cur, uid)
        friends_list = friends.get_all_friends(cur, uid)
        total_pages_read = books.num_pages_read(cur, uid)
        num_friends_targeting_user = friends.num_friends_targeting_user(cur, uid)
        num_friends = friends.num_friends_for_user(cur, uid)
        friends_targeting = friends.get_friends_targeting_user(cur, uid)

    return flask.render_template('account.html',
                                 books_read=books_read,
                                 num_books_read=num_books_read,
                                 num_lists=num_lists,
                                 user_info=user_info,
                                 #user_list=user_list,
                                 list_name=user_list,
                                 friends=friends_list,
                                 num_friends=num_friends,
                                 friends_for_user=num_friends_targeting_user,
                                 friends_targeting=friends_targeting,
                                 total_pages_read=total_pages_read)
Example #21
0
def unlk_review(uid, review_id):
    with easypg.cursor() as cur:
        f = request.form
        for key in f.keys():
            unlike_review = f.getlist(key)[0]
        reviews.unlike_review(cur, review_id, session['user_id'])
    return redirect('/reviews/' + uid + '/' + review_id)
Example #22
0
def register_index():
    errors = []
    if flask.request.method == 'POST':
        if flask.request.form['password'] != flask.request.form['password_confirm']:
            errors.append("Passwords do not match!")
        elif not re.match(r"[^@]+@[^@]+\.[^@]+", flask.request.form['email']):
            # KISS here, just confirm one @ sign, period after @ sign; no confirmation address is active
            # from: http://stackoverflow.com/a/8022584/1431509
            errors.append("Email address not valid!")
        else:
            with easypg.cursor() as cur:

                register_status, id, message = users.register_user(cur, flask.request.form)

                if register_status:
                    user = User.get(id)
                    try:
                        if flask.request.form['remeberLogin'] == "remeber-me":
                            remember = True
                    except KeyError:
                        remember = False
                    flask.ext.login.login_user(user, remember)
                    flask.flash("Registered and Logged in successfully.")
                    flask.flash("Good to meet you %s!" % flask.request.form['username'])
                else:
                    errors.append(message)


    return flask.render_template("register.html", errors=errors)
def compare_unpw(username, pw_challenge):
    """
    Compares the password given to the hashed version in the database
    :param username: The username for which to authenticate against.
    :param pw_challenge: The password to challenge authentication.
    :return:
    """

    with easypg.cursor() as cur:
        cur.execute(
            '''
            SELECT password
            FROM users
            WHERE username = %s
        ''', (username, ))

        # See this page for more information http://www.tutorialspoint.com/python/python_tuples.htm
        user_info = cur.fetchone()
        if user_info is None:
            return False
        else:
            #for row in user_info:
            #   print row
            pw = user_info[0]

            if bcrypt.hashpw(pw_challenge, pw) == pw:
                return True
            else:
                return False
Example #24
0
def register_index():
    errors = []
    if flask.request.method == "POST":
        if flask.request.form["password"] != flask.request.form["password_confirm"]:
            errors.append("Passwords do not match!")
        elif not re.match(r"[^@]+@[^@]+\.[^@]+", flask.request.form["email"]):
            # KISS here, just confirm one @ sign, period after @ sign; no confirmation address is active
            # from: http://stackoverflow.com/a/8022584/1431509
            errors.append("Email address not valid!")
        else:
            with easypg.cursor() as cur:

                register_status, id, message = users.register_user(cur, flask.request.form)

                if register_status:
                    user = BooknetUser.get(id)
                    try:
                        if flask.request.form["remeberLogin"] == "remeber-me":
                            remember = True
                    except KeyError:
                        remember = False
                    flask.ext.login.login_user(user, remember)
                    flask.flash("Registered and Logged in successfully.")
                    flask.flash("Good to meet you %s!" % flask.request.form["username"])
                    return flask.redirect(flask.url_for("home_index"))
                else:
                    errors.append(message)

    if "next" in flask.request.args:
        next = flask.request.args["next"]
    else:
        next = None
    return flask.render_template("register.html", errors=errors, next=next)
def compare_unpw(username, pw_challenge):
    """
    Compares the password given to the hashed version in the database
    :param username: The username for which to authenticate against.
    :param pw_challenge: The password to challenge authentication.
    :return:
    """

    with easypg.cursor() as cur:
        cur.execute('''
            SELECT password
            FROM users
            WHERE username = %s
        ''', (username, ))

        # See this page for more information http://www.tutorialspoint.com/python/python_tuples.htm
        user_info = cur.fetchone()
        if user_info is None:
            return False
        else:
            #for row in user_info:
             #   print row
            pw = user_info[0]

            if bcrypt.hashpw(pw_challenge, pw) == pw:
                return True
            else:
                return False
Example #26
0
def books_by_authors():
    page, sorting, sort_direction = parse_sorting()
    start, limit = get_item_limits(page)
    with easypg.cursor() as cur:
        if flask.ext.login.current_user.is_authenticated():
            total_pages, book_info = books.get_books_by_authors(
                cur, start, limit, flask.session["user_id"], sorting, sort_direction
            )
        else:
            total_pages, book_info = books.get_books_by_authors(cur, start, limit, None, sorting, sort_direction)

    if sorting:
        parameters = "&sorting=%s&sort_direction=%s" % (sorting, sort_direction)
    else:
        parameters = ""

    sort_options = {
        "Author Name": "author_name",
        "Avg. Rating": "avg_rating",
        "# Pages": "num_pages",
        "# Books": "num_books",
    }
    return render_books_index(
        "books_by_authors.html", book_info, total_pages, sort_options, parameters, "Books By Authors"
    )
Example #27
0
def display_reviews_for_book(bid):
    page, sorting, sort_direction = parse_sorting()
    start, limit = get_item_limits(page)

    with easypg.cursor() as cur:
        if flask.ext.login.current_user.is_authenticated():
            current_user_id = flask.ext.login.current_user.id
        else:
            current_user_id = None
        total_pages, review_info = reviews.get_reviews_by_book(cur, start, limit, bid, current_user_id)

    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None

    if page == total_pages:
        nextPage = None
    else:
        nextPage = page + 1

    return flask.render_template(
        "review_list.html",
        reviews=review_info["reviews"],
        page_title="Reviews for: %s" % review_info["book_info"]["title"],
        page=page,
        totalPages=total_pages,
        nextPage=nextPage,
        prevPage=prevPage,
    )
Example #28
0
def books_by_authors():
    page, sorting, sort_direction = parse_sorting()
    start, limit = get_item_limits(page)
    with easypg.cursor() as cur:
        if flask.ext.login.current_user.is_authenticated():
            total_pages, book_info = books.get_books_by_authors(
                cur, start, limit, flask.session['user_id'], sorting,
                sort_direction)
        else:
            total_pages, book_info = books.get_books_by_authors(
                cur, start, limit, None, sorting, sort_direction)

    if sorting:
        parameters = "&sorting=%s&sort_direction=%s" % (sorting,
                                                        sort_direction)
    else:
        parameters = ''

    sort_options = {
        "Author Name": "author_name",
        "Avg. Rating": "avg_rating",
        "# Pages": "num_pages",
        "# Books": "num_books"
    }
    return render_books_index('books_by_authors.html', book_info, total_pages,
                              sort_options, parameters, 'Books By Authors')
Example #29
0
def add_book_handler():
    title = flask.request.form['title']
    edition = flask.request.form['edition']
    isbn = flask.request.form['isbn']
    author_name = flask.request.form['author_name']
    publisher = flask.request.form['publisher']
    pub_date = flask.request.form['pub_date']
    pages = flask.request.form['pages']
    cover_type = flask.request.form['cover_type']
    description = flask.request.form['description']
    if title == "":
        flask.abort(402)
    if edition == "":
        flask.abort(402)
    if isbn == "":
        flask.abort(402)
    if author_name == "":
        flask.abort(402)
    if publisher == "":
        flask.abort(402)
    if pages == "":
        flask.abort(402)

    with easypg.cursor() as cur:
        aid = books.get_author_id(cur, author_name)
        bid = editBook.add_book(cur, title, edition, isbn, author_name, publisher,
                                pub_date, pages, cover_type, description, aid)
    bid = str(bid)
    return flask.redirect('/books/' + bid)
Example #30
0
def add_book_list():
    errors = []

    app.logger.info('Received new data for list from user_id %s: %s',
                    flask.ext.login.current_user.id, flask.request.form)
    with easypg.cursor() as cur:
        entry_status, messages, list_id = lists.add_book_to_list(
            cur, flask.ext.login.current_user.id, flask.request.form)
        app.logger.info("Review submitted %s - %s - %s", entry_status,
                        messages, list_id)
        if entry_status:
            for message in messages:
                flask.flash(message)
            return flask.redirect(
                flask.request.args.get("next")
                or flask.url_for("display_list", lid=list_id))
        else:
            for message in messages:
                errors.append(message)

    if 'next' in flask.request.args:
        next = flask.request.args['next']
    else:
        next = flask.url_for("reviews_index")

    return flask.redirect(next)
Example #31
0
def reviews_index():
    page, sorting, sort_direction = parse_sorting()
    start, limit = get_item_limits(page)

    with easypg.cursor() as cur:
        total_pages, review_info = reviews.get_review_range(cur, start, limit)

    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None

    if page == total_pages:
        nextPage = None
    else:
        nextPage = page + 1

    return flask.render_template(
        "review_list.html",
        reviews=review_info,
        page_title="Reviews",
        page=page,
        totalPages=total_pages,
        nextPage=nextPage,
        prevPage=prevPage,
    )
Example #32
0
def login_index():
    # Login page

    errors = []
    if flask.request.method == "POST":
        # login and validate the user...
        with easypg.cursor() as cur:

            login_status = users.validate_login(cur, flask.request.form)
            if login_status > 0:
                user = BooknetUser.get(login_status)
                try:
                    if flask.request.form["remeberLogin"] == "remeber-me":
                        remember = True
                except KeyError:
                    remember = False
                print user.is_active
                flask.ext.login.login_user(user, remember)
                flask.flash("Logged in successfully.")
                return flask.redirect(flask.request.args.get("next") or flask.url_for("home_index"))
            else:
                errors.append("Username or password not accepted.")

    if "next" in flask.request.args:
        next = flask.request.args["next"]
    else:
        next = None
    return flask.render_template("login.html", errors=errors, next=next)
Example #33
0
def add_book(bid):
    errors = []
    if flask.request.method == 'POST':
        with easypg.cursor() as cur:
            edit_status, messages, book_id = books.add_book(
                cur, bid, flask.ext.login.current_user.id, flask.request.form)
            print "Posted book data: %s..." % messages
            if edit_status:
                for message in messages:
                    flask.flash(message)
                return flask.redirect(
                    flask.request.args.get("next")
                    or flask.url_for("display_book", bid=book_id))
            else:
                for message in messages:
                    errors.append(message)

    if 'next' in flask.request.args:
        next = flask.request.args['next']
    else:
        next = flask.url_for("home_index")

    book_info = {'title': 'New Book Addition', 'core_id': '0'}
    return flask.render_template("book_edit_form.html",
                                 book_info=book_info,
                                 page_title="Add A Book!",
                                 error=errors,
                                 next=next)
Example #34
0
def display_reviews_for_book(bid):
    page, sorting, sort_direction = parse_sorting()
    start, limit = get_item_limits(page)

    with easypg.cursor() as cur:
        if flask.ext.login.current_user.is_authenticated():
            current_user_id = flask.ext.login.current_user.id
        else:
            current_user_id = None
        total_pages, review_info = reviews.get_reviews_by_book(
            cur, start, limit, bid, current_user_id)

    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None

    if page == total_pages:
        nextPage = None
    else:
        nextPage = page + 1

    return flask.render_template('review_list.html',
                                 reviews=review_info['reviews'],
                                 page_title='Reviews for: %s' %
                                 review_info['book_info']['title'],
                                 page=page,
                                 totalPages=total_pages,
                                 nextPage=nextPage,
                                 prevPage=prevPage)
Example #35
0
def add_book_list():
    errors = []

    app.logger.info(
        "Received new data for list from user_id %s: %s", flask.ext.login.current_user.id, flask.request.form
    )
    with easypg.cursor() as cur:
        entry_status, messages, list_id = lists.add_book_to_list(
            cur, flask.ext.login.current_user.id, flask.request.form
        )
        app.logger.info("Review submitted %s - %s - %s", entry_status, messages, list_id)
        if entry_status:
            for message in messages:
                flask.flash(message)
            return flask.redirect(flask.request.args.get("next") or flask.url_for("display_list", lid=list_id))
        else:
            for message in messages:
                errors.append(message)

    if "next" in flask.request.args:
        next = flask.request.args["next"]
    else:
        next = flask.url_for("reviews_index")

    return flask.redirect(next)
def unlk_review(uid, review_id):
    with easypg.cursor() as cur:
        f = request.form
        for key in f.keys():
            unlike_review = f.getlist(key)[0]
        reviews.unlike_review(cur, review_id, session['user_id'])
    return redirect('/reviews/' + uid + '/' + review_id)
def dlt_review(uid, rid):
    with easypg.cursor() as cur:
        f = request.form
        for key in f.keys():
            remove_review = f.getlist(key)[0]
        reviews.delete_review(cur, remove_review)
    return redirect('/users/' + uid + '/reviews')
def get_search_results():
    if 'q' in request.args:
        query = request.args['q']
    if 'dropdown' in request.args:
        type = request.args['dropdown']
    else:
        abort(400)

    books = None
    authors = None
    categories = None
    users = None

    with easypg.cursor() as cur:
        if type == "Book":
            books = queries.search_titles(cur, query)
        if type == "Author":
            authors = queries.search_authors(cur, query)
        if type == "Categories":
            categories = queries.search_categories(cur, query)
        if type == "User":
            users = queries.search_users(cur, query)


    return render_template('search_results.html',
                           query=query,
                           books=books,
                           users=users,
                           authors=authors,
                           categories=categories)
def user_page(uid):
    with easypg.cursor() as cur:
        following = follows.get_follow_status(cur, session['username'], uid)
    return render_template('user_main_page.html',
                                 uid = uid,
                                 following = following
                                )
def unfollow_from_user_page(uid):
    f = request.form
    for key in f.keys():
        remove_follower = f.getlist(key)[0]
    with easypg.cursor() as cur:
        follows.unfollow(cur, session['username'], remove_follower)
    return redirect('/users/' + uid)
def print_followers(uid):
    if 'page' in request.args:
        page = int(request.args['page'])
    else:
        page = 1
    if page <= 0:
        abort(404)

    id = session['username']
    with easypg.cursor() as cur:
        followers = follows.get_followers(cur, page, id)
        total_pages = follows.get_follower_pg_cnt(cur, id)
        return render_template('followers.html',
                                     follow = followers,
                                     page = page,
                                     total_pages = total_pages,
                                     user = id
                                     )
    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None
    if page < total_pages:
        nextPage = page + 1
    else:
        nextPage = None
def print_followees(user_id):
    if request.method == "GET":
        if 'page' in request.args:
            page = int(request.args['page'])
        else:
            page = 1
        if page <= 0:
            abort(404)

        with easypg.cursor() as cur:
            followees = follows.get_followees(cur, page, user_id)
            total_pages = follows.get_followee_pg_cnt(cur, user_id)
            return render_template('followees.html',
                                         follow = followees,
                                         page = page,
                                         total_pages = total_pages,
                                         uid = user_id
                                        )

        if page > 1:
            prevPage = page - 1
        else:
            prevPage = None
        if page < total_pages:
            nextPage = page + 1
        else:
            nextPage = None
Example #43
0
def login_index():
    # Login page

    errors = []
    if flask.request.method == 'POST':
        # login and validate the user...
        with easypg.cursor() as cur:

            login_status = users.validate_login(cur, flask.request.form)
            if login_status > 0:
                user = BooknetUser.get(login_status)
                try:
                    if flask.request.form['remeberLogin'] == "remeber-me":
                        remember = True
                except KeyError:
                    remember = False
                print user.is_active
                flask.ext.login.login_user(user, remember)
                flask.flash("Logged in successfully.")
                return flask.redirect(
                    flask.request.args.get("next")
                    or flask.url_for("home_index"))
            else:
                errors.append("Username or password not accepted.")

    if 'next' in flask.request.args:
        next = flask.request.args['next']
    else:
        next = None
    return flask.render_template("login.html", errors=errors, next=next)
Example #44
0
def display_books_with_covers():
    page, sorting, sort_direction = parse_sorting()
    start, limit = get_item_limits(page)
    with easypg.cursor() as cur:
        if flask.ext.login.current_user.is_authenticated():
            total_pages, publisher_info = books.get_books_with_covers(
                cur, start, limit, flask.session['user_id'], sorting,
                sort_direction)
        else:
            total_pages, publisher_info = books.get_books_with_covers(
                cur, start, limit, None, sorting, sort_direction)

    sort_options = {
        "Title": "book_title",
        "Publication Date": "publication_date",
        "Avg. Rating": "avg_rating",
        "Number of Readers": "num_readers"
    }
    if sorting:
        parameters = "&sorting=%s&sort_direction=%s" % (sorting,
                                                        sort_direction)
    else:
        parameters = ''
    return render_books_index('books_index.html', publisher_info, total_pages,
                              sort_options, parameters, 'Books With Covers')
Example #45
0
def display_publisher(pid):
    page, sorting, sort_direction = parse_sorting()
    start, limit = get_item_limits(page)
    with easypg.cursor() as cur:
        if flask.ext.login.current_user.is_authenticated():
            total_pages, publisher_info = books.get_books_by_publisher(
                cur, start, limit, pid, flask.session["user_id"], sorting, sort_direction
            )
        else:
            total_pages, publisher_info = books.get_books_by_publisher(
                cur, start, limit, pid, None, sorting, sort_direction
            )

    sort_options = {
        "Title": "book_title",
        "Publication Date": "publication_date",
        "Avg. Rating": "avg_rating",
        "Number of Readers": "num_readers",
    }
    if sorting:
        parameters = "&sorting=%s&sort_direction=%s" % (sorting, sort_direction)
    else:
        parameters = ""
    return render_books_index(
        "author.html", publisher_info, total_pages, sort_options, parameters, "Books - %s" % publisher_info["name"]
    )
Example #46
0
def user_dashboard_following():
    with easypg.cursor() as cur:
        user_info = users.get_user_feed(cur,
                                        flask.ext.login.current_user.get_id())
    # user_info['name'] = flask.ext.login.current_user.name
    return flask.render_template('dashboard_following.html',
                                 user_info=user_info)
Example #47
0
def add_book(bid):
    errors = []
    if flask.request.method == "POST":
        with easypg.cursor() as cur:
            edit_status, messages, book_id = books.add_book(
                cur, bid, flask.ext.login.current_user.id, flask.request.form
            )
            print "Posted book data: %s..." % messages
            if edit_status:
                for message in messages:
                    flask.flash(message)
                return flask.redirect(flask.request.args.get("next") or flask.url_for("display_book", bid=book_id))
            else:
                for message in messages:
                    errors.append(message)

    if "next" in flask.request.args:
        next = flask.request.args["next"]
    else:
        next = flask.url_for("home_index")

    book_info = {"title": "New Book Addition", "core_id": "0"}
    return flask.render_template(
        "book_edit_form.html", book_info=book_info, page_title="Add A Book!", error=errors, next=next
    )
def get_frnd_actvty(uid):
    with easypg.cursor() as cur:
        user_id = queries.get_user_id(cur, uid)
        activity_info = activity.get_friend_activity(cur, user_id)
    return render_template('activity_list.html',
                           activity_info = activity_info,
                           uid = uid)
Example #49
0
def display_review(rid):
    with easypg.cursor() as cur:
        review_info = reviews.get_review(cur, rid)
    if 'next' in flask.request.args:
        next = flask.request.args['next']
    else:
        next = flask.url_for("reviews_index")
    return flask.render_template("review.html", review=review_info, next=next)
Example #50
0
def display_log(lid):
    with easypg.cursor() as cur:
        log_info = logs.get_log(cur, lid)
    if 'next' in flask.request.args:
        next = flask.request.args['next']
    else:
        next = flask.url_for("home_index")
    return flask.render_template("log.html", log=log_info, next=next)
Example #51
0
def unfollow_from_frinds_list(user_id):
    f = request.form
    for key in f.keys():
        remove_follower = f.getlist(key)[0]
    if request.method == "POST":
        with easypg.cursor() as cur:
            #remove_follower = request.form['unfollow']
            follows.unfollow(cur, session['username'], remove_follower)
        return redirect('/follows/' + user_id)
Example #52
0
def home_index():
    with easypg.cursor() as cur:
        pages, book_info = books.get_spotlight_books(cur, 4)
        pages, review_info = reviews.get_spotlight_reviews(cur, 4)
        list_info = lists.get_spotlight_lists(cur, 4)
    return flask.render_template('home.html',
                                 books=book_info,
                                 reviews=review_info,
                                 lists=list_info)
Example #53
0
def get_author(aid):
    with easypg.cursor() as cur:
        info = authors.get_author(cur, aid)

    if info is None:
        flask.abort(404)

    return flask.render_template('authors.html',
                                 author_id=aid,
                                 **info)
Example #54
0
def get_title(tid):

    if request.method == 'GET':
        with easypg.cursor() as cur:
            title_info = books.get_title(cur, tid)
        if title_info is None:
            abort(404)

        return render_template('book.html', edition_id=tid, **title_info)

    if request.method == 'POST':
        with easypg.cursor() as cur:
            print "Working!!!"
            #rating = request.form['rating']
            review = request.form['review']
            #user_lists.add_rating(cur, session['user_id'],tid, rating)
            user_lists.add_review(cur, session['user_id'], tid, review, 0)
            print "done!"
        return redirect('/books/' + tid)
Example #55
0
def get_review(uid, rid):
    with easypg.cursor() as cur:
        review_info = reviews.get_user_review(cur, rid)
        author_list = reviews.get_author_names(cur, rid)
        num_likes = reviews.get_likes(cur, rid, session['user_id'])
    return render_template('review_text.html',
                           uid=uid,
                           author_list=author_list,
                           num_likes=num_likes,
                           **review_info)
Example #56
0
def users_index():
    if 'sorting' in flask.request.args:
        sorting = flask.request.args['sorting']
    else:
        sorting = None
    if 'sort_direction' in flask.request.args:
        sort_direction = flask.request.args['sort_direction']
    else:
        sort_direction = None

    if 'page' in flask.request.args:
        page = int(flask.request.args['page'])
    else:
        page = 1
    if page <= 0:
        flask.abort(404)

    with easypg.cursor() as cur:
        total_pages = users.get_total_pages(cur)

    with easypg.cursor() as cur:
        if flask.ext.login.current_user.is_authenticated():
            user_info = users.get_all_users(cur, page,
                                            flask.session['user_id'])
        else:
            user_info = users.get_all_users(cur, page)

    if page > 1:
        prevPage = page - 1
    else:
        prevPage = None

    if page == total_pages:
        nextPage = None
    else:
        nextPage = page + 1

    return flask.render_template('users.html',
                                 users=user_info,
                                 page=page,
                                 totalPages=total_pages,
                                 nextPage=nextPage,
                                 prevPage=prevPage)
Example #57
0
def user_dashboard():
    if flask.ext.login.current_user.is_authenticated():
        current_user_id = flask.session['user_id']
    else:
        current_user_id = None
    with easypg.cursor() as cur:
        user_info = users.get_user(cur, current_user_id, current_user_id)

    # print user_info
    return flask.render_template('dashboard_overview.html',
                                 user_info=user_info)
Example #58
0
def edit_list(uid, list_id):
    if request.method == "GET":
        with easypg.cursor() as cur:
            list_books = user_lists.get_books_in_list(cur, list_id)

        #if list_books is None:
        #  abort(404)

        return render_template('edit_list.html',
                               uid=uid,
                               l_id=list_id,
                               list_books=list_books)
Example #59
0
def display_book(bid):
    with easypg.cursor() as cur:
        if flask.ext.login.current_user.is_authenticated():
            book_info = books.get_book(cur, bid,
                                       flask.ext.login.current_user.id)
        else:
            book_info = books.get_book(cur, bid)
    # print book_info
    if 'next' in flask.request.args:
        next = flask.request.args['next']
    else:
        next = flask.url_for("home_index")
    return flask.render_template("book.html", book_info=book_info, next=next)
Example #60
0
def display_list(lid):
    with easypg.cursor() as cur:
        if flask.ext.login.current_user.is_authenticated():
            list_info = lists.get_list(cur, lid,
                                       flask.ext.login.current_user.id)
        else:
            list_info = lists.get_list(cur, lid)

    if 'next' in flask.request.args:
        next = flask.request.args['next']
    else:
        next = flask.url_for("home_index")
    return flask.render_template("list.html", list=list_info, next=next)