示例#1
0
    def delete_author_everywhere(self, author):
        # Deleting the author in the ComicBook model
        comics = ComicBook.query().fetch()
        aux = list()
        if len(comics) > 0:
            for comic in comics:
                if len(comic.authors) > 0:
                    for comic_author in comic.authors:
                        if author.name != comic_author.author.name:
                            aux.append(comic_author)
                        del comic_author
                    comic.authors = aux
                    comic.put()
                    aux = list()
                del comic

        # Deleting the author in the ComicBook_Author model
        comic_authors = ComicBook_Author.query().fetch()
        if len(comic_authors) > 0:
            for comic_author in comic_authors:
                if author.name == comic_author.author.name:
                    comic_author.key.delete()
                del comic_author

        del comics, comic_authors, aux
示例#2
0
    def get_statistics(self):
        statistics = dict()
        statistics["read"] = 0
        statistics["unread"] = 0
        statistics["comic"] = 0
        statistics["manga"] = 0
        statistics["anthology"] = 0
        statistics["american"] = 0
        statistics["european"] = 0
        statistics["other"] = 0
        statistics["value"] = 0

        comics = ComicBook.query(
            ComicBook.users.username == self.session.get("session_name"))
        for comic in comics:
            for user_comic in comic.users:
                if user_comic.username == self.session.get('session_name'):
                    # Already read or not
                    if user_comic.state == "read":
                        statistics["read"] += 1
                    else:
                        statistics["unread"] += +1
                    # Comics by type
                    if comic.type == "comic":
                        statistics["comic"] += 1
                    elif comic.type == "manga":
                        statistics["manga"] += 1
                    else:
                        statistics["anthology"] += 1
                    # Comics by origin
                    if comic.origin == "american":
                        statistics["american"] += 1
                    elif comic.origin == "european":
                        statistics["european"] += 1
                    else:
                        statistics["other"] += 1
                del user_comic
            statistics["value"] += comic.value
            del comic

        del comics  # Delete variables to free memory
        return statistics
示例#3
0
    def modify_author_everywhere(self, old_name, new_name):
        # Modify the author in the ComicBook model
        comics = ComicBook.query().fetch()
        if len(comics) > 0:
            for comic in comics:
                if len(comic.authors) > 0:
                    for comic_author in comic.authors:
                        if old_name == comic_author.author.name:
                            comic_author.author.name = new_name
                            comic.put()
                        del comic_author
                del comic

        # Modify the author in the ComicBook_Author model
        comic_authors = ComicBook_Author.query().fetch()
        if len(comic_authors) > 0:
            for comic_author in comic_authors:
                if old_name == comic_author.author.name:
                    comic_author.author.name = new_name
                    comic_author.put()
                del comic_author

        del comics, comic_authors
示例#4
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # If an client is logged in delete the comic
        if self.session.get('session_role') == 'client':
            # Retrieving the comic key
            key = self.request.get("key", "")
            key = ndb.Key(urlsafe=key)
            shelving = key.get()  # Get the db shelving with that key

            keys_page_list = self.request.get(
                "keys_page_list",
                "")  # Comic keys (only comics in the current page)
            aux_all_keys = self.request.get(
                "all_keys", "")  # All the comic keys (for the order field)

            # Initialize variables
            all_keys = list()  # All the comic keys (for the order field)
            aux = list()  # Support variable
            aux3 = list()  # Support variable
            shelving_name = list()  # Shelving name

            # Transform the HTML string in a list
            aux_all_keys = self.transform_keys(aux_all_keys)

            # Get the shelvings
            shelvings = Shelving.query(
                Shelving.username == self.session.get('session_name')).order(
                    Shelving.name).fetch()

            all_comics = ComicBook.query().fetch()
            # Get all comics that belongs to the current user
            if not self.session.get("shelving"):
                comics = ComicBook.query(
                    ComicBook.users.username ==
                    self.session.get('session_name')).order(
                        ComicBook.users.addition_date
                    )  # All comics ordered by the addition date
                all_comics_user = copy.copy(
                    comics)  # ALL comics (for the search field)
                all_comics_user = all_comics_user.fetch()
            else:
                key = ndb.Key(urlsafe=self.session.get("shelving"))
                comics = ComicBook.query(
                    ComicBook.users.username == self.session.get(
                        'session_name'),
                    ComicBook.users.shelving == key).order(
                        ComicBook.users.addition_date
                    )  # Comics in the shelving ordered by the addition date
                shelving2 = key.get()
                shelving_name = shelving2.name
                del shelving2
                all_comics_user = ComicBook.query(
                    ComicBook.users.username == self.session.get(
                        'session_name')).fetch(
                        )  # ALL comics (for the search field)

            for comic2 in comics:  # Get ALL the keys
                aux.append(comic2.key.urlsafe())
                del comic2

            for key3 in aux_all_keys:  # Compare the "list" given by HTML with aux for making the new all keys list (all_keys)
                for key2 in aux:
                    if key3 == str(key2):
                        key2 = ndb.Key(urlsafe=key2)
                        aux3.append(key2)
                        all_keys.append(key2.urlsafe())
                        break
                    del key2
                del key3

            # Get db comics
            offset = (self.session.get('current_number_page') -
                      1) * self.session.get('num_elems_page')
            if len(aux3) > 0:
                comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(
                    self.session.get('num_elems_page'), offset=offset)
                # Get the comics (if --> default, else --> see shelving)
                if not self.session.get('shelving'):
                    comics = self.get_comics_read_and_without_shelving(
                        comics
                    )  # Get read comics and the ones that aren't in a shelving
                else:
                    self.get_comics_read(comics)  # Get read comics
            else:
                comiss = list()

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            # Variables to be sent to the HTML page
            values = {
                "lang":
                lang,  # Language strings
                "session_name":
                self.session.get('session_name'),  # User name
                "session_role":
                self.session.get('session_role'),  # User role
                "session_picture":
                self.get_session_image(
                    self.session.get('session_name')),  # User picture
                "session_genre":
                self.session.get('session_genre'),  # User genre
                "comics":
                comics,  # Comics
                "current_number_page":
                self.session.get('current_number_page'),  # Current number page
                "pages":
                self.session.get('pages'),  # Pages for the pagination
                "last_page":
                self.session.get('last_page'),  # Last page number
                "keys_page_list":
                keys_page_list,  # Comic keys that are currently in the page
                "all_keys":
                all_keys,  # All comic keys
                "all_comics":
                all_comics,  # ALL comic (for the user search field)
                "all_comics_user":
                all_comics_user,  # All user comics (for the search field)
                "authors":
                self.get_authors(),  # Authors for adding them to the comics
                "shelvings":
                shelvings,  # Shelvings list
                "shelving_name":
                shelving_name  # Shelving name
            }

            # If the comic exists
            if shelving and shelving is not None:
                # Delete all shelves of the shelving and quit all comics
                self.delete_shelving(shelving, all_comics_user)

                # Delete db comic
                shelving.key.delete()
                values["ok_message"] = lang[
                    "shelving_deleted_successfully"]  # Ok message (shelving deleted successfully)

                # Get the shelvings
                shelvings = Shelving.query(
                    Shelving.username == self.session.get(
                        'session_name')).order(Shelving.name).fetch()
                values["shelvings"] = shelvings

                # Setting pagination
                ##############################################################################################
                pages_to_show = self.session.get(
                    'pages_to_show'
                )  # Number of pages that shows the pagination
                pages = list(
                )  # Pages for the pagination (it's a list because of django for templates)

                # Get all db comics (Limited to the number given by the session variable [10 by default])
                num_total = len(aux3)  # Total number of elements
                if len(aux3) > 0:
                    if not self.session.get("shelving"):
                        comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(
                            self.session.get('num_elems_page'),
                            offset=offset)  # List not empty
                    else:
                        comics = ComicBook.query(
                            ComicBook.users.username == self.session.get(
                                "session_name"))  # List not empty
                        num_total = len(aux3)
                        aux3 = list()
                        for comic in comics:
                            aux3.append(comic.key)
                            del comic
                        comics = comics.fetch(
                            self.session.get('num_elems_page'))
                else:
                    if not self.session.get("shelving"):
                        comics = list()
                    else:
                        comics = ComicBook.query(
                            ComicBook.users.username == self.session.get(
                                "session_name"))  # List not empty
                        num_total = len(aux3)
                        aux3 = list()
                        for comic in comics:
                            aux3.append(comic.key)
                            del comic
                        comics = comics.fetch(
                            self.session.get('num_elems_page'))

                # If the total number of elements is above 0 do the pagination
                if num_total > 0 and len(comics) > 0:
                    # Get the number of pages for the pagination
                    num_elems_page = self.session.get(
                        'num_elems_page'
                    )  # Number of elements (comics) per page
                    num_pages = num_total / num_elems_page  # Number of pages

                    # If there are less elements than session["num_elems_page"]
                    if num_pages == 0:
                        num_pages = 1  # At least one page
                    # Else
                    else:
                        # If the rest of the division is above 0
                        if (num_total % num_elems_page) > 0:
                            num_pages = (num_total / num_elems_page
                                         ) + 1  # It's necessary other page
                        else:
                            num_pages = (num_total / num_elems_page
                                         )  # It doesn't need other page

                    self.session['last_page'] = num_pages  # Last page

                    # Set the pages for the pagination
                    for i in range(1, num_pages + 1):
                        pages.append(i)

                    # Set number of pages for the pagination (pagination only shows 3 pages)
                    current_number_page = self.session.get(
                        'current_number_page')
                    # If the current page is 1
                    if current_number_page == 1:
                        pages = pages[0:pages_to_show]  # Shows pages 1,2,3
                    # If the current page is the final page
                    elif current_number_page == num_pages:  # Shows the last three pages
                        if (num_pages - pages_to_show) >= 0:
                            pages = pages[(num_pages - pages_to_show):]
                        else:
                            pages = pages[0:pages_to_show]
                    # Else
                    else:
                        pages = pages[(current_number_page - 2):(
                            current_number_page +
                            1)]  # Show the current, last and next pages

                    self.session['pages'] = pages  # Pages for the pagination

                    del num_elems_page, num_pages, current_number_page  # Delete variables to free memory

                # If page is empty do the same, but return to the to the last page next to the current page
                elif num_total > 0 and len(comics) == 0:
                    # Get all db comics (Limited to the number given by the session variable [10 by default])
                    offset = (self.session.get('current_number_page') -
                              2) * self.session.get('num_elems_page')
                    comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(
                        self.session.get('num_elems_page'), offset=offset)

                    # Get the number of pages for the pagination
                    num_elems_page = self.session.get(
                        'num_elems_page'
                    )  # Number of elements (comics) per page
                    num_pages = num_total / num_elems_page  # Number of pages

                    # If there are less elements than session["num_elems_page"]
                    if num_pages == 0:
                        num_pages = 1  # At least one page
                    # Else
                    else:
                        # If the rest of the division is above 0
                        if (num_total % num_elems_page) > 0:
                            num_pages = (num_total / num_elems_page
                                         ) + 1  # It's necessary other page
                        else:
                            num_pages = (num_total / num_elems_page
                                         )  # It doesn't need other page

                    current_number_page = num_pages  # The previous last page doesn't already exist, so it has to be the last page of the new list
                    self.session['last_page'] = num_pages  # Last page

                    # Set the pages for the pagination
                    for i in range(1, num_pages + 1):
                        pages.append(i)

                    # Set number of pages for the pagination (pagination only shows 3 pages)
                    # If the current page is 1
                    if current_number_page == 1:
                        pages = pages[0:pages_to_show]  # Shows pages 1,2,3
                    # If the current page is the final page
                    elif current_number_page == num_pages:  # Shows the last three pages
                        if (num_pages - pages_to_show) >= 0:
                            pages = pages[(num_pages - pages_to_show):]
                        else:
                            pages = pages[0:pages_to_show]
                    # Else
                    else:
                        pages = pages[(current_number_page - 2):(
                            current_number_page +
                            1)]  # Show the current, last and next pages

                    self.session['pages'] = pages  # Pages for the pagination
                    self.session[
                        'current_number_page'] = current_number_page  # Current number page

                    del num_elems_page, num_pages, current_number_page  # Delete variables to free memory
                ###########################################################################################

                # Variables to be sent to the html
                if not self.session.get("shelving"):
                    values[
                        "comics"] = self.get_comics_read_and_without_shelving(
                            comics)
                else:
                    self.session["shelving"] = None
                    values["shelving_name"] = list()
                    values[
                        "comics"] = self.get_comics_read_and_without_shelving(
                            comics)

                values["all_comics_user"] = copy.copy(comics)
                values["pages"] = self.session.get(
                    'pages')  # Pages for the pagination
                values["last_page"] = self.session.get(
                    'last_page')  # Last page number
                values["all_keys"] = all_keys  # All comic keys
                values["current_number_page"] = self.session.get(
                    'current_number_page')  # Current number page

                # Setting the comic keys list that are currently in the page
                keys_page_list = list()
                for comic in comics:
                    keys_page_list.append(comic.key.urlsafe())
                values["keys_page_list"] = keys_page_list

                del pages_to_show, pages, num_total  # Delete variables to free memory

            # Else show an error message
            else:
                values["error_message"] = lang[
                    "shelving_not_deleted"]  # Error message (Shelving couldn't be deleted)

            del key, shelving, keys_page_list, aux_all_keys, all_keys, aux, aux3, all_comics, offset, comics,\
                lang, shelving_name  # Delete variables to free memory
            self.session_store.save_sessions(self.response)  # Save sessions
            self.response.write(
                jinja.render_template("/library/default.html",
                                      **values))  # Go to the comics home page

        # Else redirect to the login page
        else:
            self.redirect("/login")
示例#5
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the admin is logged in
        if self.session.get('session_role') == 'client':
            # If it's logged in, get the session variables, show the home page
            # Get the shelving attributes
            name = self.request.get("name", "")                           # Shelving name
            name = name.encode("utf8")
            picture = self.request.get("picture", "")                     # Shelving picture

            keys_page_list = self.request.get("keys_page_list", "")     # Comic keys (only comics in the current page)
            aux_all_keys = self.request.get("all_keys", "")             # All the comic keys (for the order field)

            # Initialize variables
            all_keys = list()                                           # All the comic keys (for the order field)
            aux = list()                                                # Support list
            aux3 = list()                                               # Support list
            shelving_name = list()                                      # Shelving name

            all_comics = ComicBook.query().fetch()

            # Get the shelvings
            shelvings = Shelving.query(Shelving.username == self.session.get('session_name')).order(Shelving.name).fetch()

            offset = (self.session.get('current_number_page') - 1) * self.session.get('num_elems_page')  # Number of elements to ignore in the query

            # Transform the HTML string in a list
            aux_all_keys = self.transform_keys(aux_all_keys)

            # Get all comics that belongs to the current user
            if not self.session.get("shelving"):
                comics = ComicBook.query(ComicBook.users.username == self.session.get('session_name')).order(ComicBook.users.addition_date)  # All comics ordered by the addition date
                all_comics_user = copy.copy(comics)  # ALL comics (for the search field)
                all_comics_user = all_comics_user.fetch()
            else:
                key = ndb.Key(urlsafe=self.session.get("shelving"))
                comics = ComicBook.query(ComicBook.users.username == self.session.get('session_name'), ComicBook.users.shelving == key).order(ComicBook.users.addition_date)  # Comics in the shelving ordered by the addition date
                shelving = key.get()
                shelving_name = shelving.name
                del shelving
                all_comics_user = ComicBook.query(ComicBook.users.username == self.session.get('session_name')).fetch()  # ALL comics (for the search field)

            for comic in comics:  # Get ALL the keys
                aux.append(comic.key.urlsafe())
                del comic

            for key in aux_all_keys:  # Compare the "list" given by HTML with aux for making the new all keys list (all_keys)
                for key2 in aux:
                    if key == str(key2):
                        key2 = ndb.Key(urlsafe=key)
                        aux3.append(key2)
                        all_keys.append(key2.urlsafe())
                        break
                    del key2
                del key

            # Get db comics
            if len(aux3) > 0:
                comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(self.session.get('num_elems_page'), offset=offset)
                # Get the comics (if --> default, else --> see shelving)
                if not self.session.get('shelving'):
                    comics = self.get_comics_read_and_without_shelving(comics)  # Get read comics and the ones that aren't in a shelving
                else:
                    self.get_comics_read(comics)  # Get read comics
            else:
                comics = list()

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            keys_page_list = list()

            # Variables to be sent to the HTML page
            values = {
                "lang": lang,                                                                   # Language strings
                "session_name": self.session.get('session_name'),                               # User name
                "session_role": self.session.get('session_role'),                               # User role
                "session_picture": self.get_session_image(self.session.get('session_name')),    # User picture
                "session_genre": self.session.get('session_genre'),                             # User genre
                "comics": comics,                                                               # Comics
                "current_number_page": self.session.get('current_number_page'),                 # Current number page
                "pages": self.session.get('pages'),                                             # Pages for the pagination
                "last_page": self.session.get('last_page'),                                     # Last page number
                "keys_page_list": keys_page_list,                                               # Comic keys that are currently in the page
                "all_keys": all_keys,                                                           # All comic keys
                "all_comics": all_comics,                                                       # ALL comic (for the user search field)
                "all_comics_user": all_comics_user,                                             # All user comics (for the search field)
                "authors": self.get_authors(),                                                  # Authors for adding them to the comics
                "shelvings": shelvings,                                                         # Shelvings list
                "shelving_name": shelving_name                                                  # Shelving name
            }

            # If the user enters all the attributes (the database can have more than one shelving with the same name)
            if len(name) > 0:
                # Check the comic attributes
                if picture != "":
                    picture = images.resize(picture, 300, 250)
                else:
                    picture = None

                # Add the new shelving to the home page
                shelving = Shelving(name=name, picture=picture, username=self.session.get('session_name'))

                aux2 = shelving.put()
                time.sleep(1)

                # If the shelving was successfully added
                if aux2 is not None:
                    # Adding the new shelving to the list
                    shelvings.append(shelving)

                    # Setting pagination
                    ##############################################################################################
                    pages_to_show = self.session.get('pages_to_show')   # Number of pages that shows the pagination
                    pages = list()  # Pages for the pagination (it's a list because of django for templates)

                    # Get all db comics (Limited to the number given by the session variable [10 by default])
                    if len(aux3) > 0:
                        comics = ComicBook.query(ComicBook.key.IN(aux3)).order(-ComicBook.save_date).fetch(self.session.get('num_elems_page'), offset=offset)
                    else:
                        comics = ComicBook.query().fetch()

                    # Setting the new keys list for the comics currently in the page (allows to use the "Delete page" button)
                    for comic in comics:
                        keys_page_list.append(comic.key.urlsafe())
                        del comic

                    num_total = len(all_comics_user)  # Total number of elements

                    # If the total number of elements is above 0 do the pagination
                    if num_total > 0:
                        # Get the number of pages for the pagination
                        num_elems_page = self.session.get('num_elems_page')  # Number of elements (comics) per page
                        num_pages = num_total / num_elems_page               # Number of pages

                        # If there are less elements than session["num_elems_page"]
                        if num_pages == 0:
                            num_pages = 1  # At least one page
                        # Else
                        else:
                            # If the rest of the division is above 0
                            if (num_total % num_elems_page) > 0:
                                num_pages = (num_total / num_elems_page) + 1    # It's necessary other page
                            else:
                                num_pages = (num_total / num_elems_page)        # It doesn't need other page

                        self.session['last_page'] = num_pages  # Last page

                        # Set the pages for the pagination
                        for i in range(1, num_pages + 1):
                            pages.append(i)

                        # Set number of pages for the pagination (pagination only shows 3 pages)
                        current_number_page = self.session.get('current_number_page')
                        # If the current page is 1
                        if current_number_page == 1:
                            pages = pages[0:pages_to_show]  # Shows pages 1,2,3
                        # If the current page is the final page
                        elif current_number_page == num_pages:  # Shows the last three pages
                            if (num_pages - pages_to_show) >= 0:
                                pages = pages[(num_pages - pages_to_show):]
                            else:
                                pages = pages[0:pages_to_show]
                        # Else
                        else:
                            pages = pages[(current_number_page - 2):(current_number_page + 1)]  # Show the current, last and next pages

                        self.session['pages'] = pages  # Pages for the pagination

                        # Variables to be sent to the HTML page
                        # Get the comics (if --> default, else --> see shelving)
                        if not self.session.get('shelving'):
                            values["comics"] = self.get_comics_read_and_without_shelving(comics)  # Get read comics and the ones that aren't in a shelving
                        else:
                            self.get_comics_read(comics)  # Get read comics
                            values["comics"] = comics

                        values["pages"] = self.session.get('pages')                             # Pages for the pagination
                        values["last_page"] = self.session.get('last_page')                     # Last page number

                        del num_elems_page, num_pages, current_number_page  # Delete variables to free memory
                    ###########################################################################################
                    # Variables to be sent to the HTML page
                    values["ok_message"] = lang["shelving_added_successfully"]    # Ok message (shelving added successfully)
                    values["keys_page_list"] = keys_page_list                     # Comics keys that are currently in the page
                    values["all_keys"] = all_keys                                 # All comic keys
                    values["shelvings"] = shelvings                               # Shelvings list

                    del pages_to_show, pages, comics, num_total, shelving    #  Delete variables to free memory

                # If wasn't successfully added
                else:
                    del shelving, aux2        # Delete variables to free memory

                    # Variables to be sent to the HTML page
                    values["error_message"] = lang["error_add"]  # Error message (The addition failed)

            # Else show an error message
            else:
                # Values to be sent to the HTML page
                values["error_message"] = lang["must_insert_all_shelving_attributes"]   # Error message (You must enter all shelving data)

            del lang, offset, keys_page_list, aux_all_keys, all_keys, all_comics, aux, aux3, picture,\
                name, shelvings, all_comics_user, shelving_name     # Delete variables to free memory
            self.session_store.save_sessions(self.response)  # Save sessions
            self.response.write(jinja.render_template("/library/default.html", **values))  # Go to the comicss home page

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#6
0
    def get(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in. If it's logged in, show the home page
        if self.session.get('session_role') == 'client':
            user = User.query(User.name == self.session.get(
                "session_name")).fetch()  # Current user

            # If users exists, get friends and friends requests
            if user and len(user) > 0:
                self.session['page_name'] = "/friends"  # Current page name

                user = user[0]
                # Get db friends and friend requests
                all = Friend.query().order(-Friend.addition_date)

                # Db friends
                friends = copy.copy(all)
                friends = friends.filter(Friend.is_friend == True)
                friends = friends.filter(
                    ndb.OR(Friend.who_ask == user.key,
                           Friend.who_answer == user.key))
                friends = friends.order(-Friend.addition_date)
                aux = list()
                for friend in friends:
                    if friend.who_answer != user.key:
                        aux.append(friend.who_answer.get())
                    elif friend.who_ask != user.key:
                        aux.append(friend.who_ask.get())
                    del friend
                friends = aux

                # Db friends requests
                requests = copy.copy(all)
                requests = requests.filter(Friend.is_friend == False)
                requests = requests.filter(Friend.who_answer == user.key)
                requests = requests.order(-Friend.addition_date)
                aux = list()
                for request in requests:
                    aux.append(request.who_ask.get())
                    del request
                requests = aux

                # Set the default language of the app
                if self.session['session_idiom'] == "spa":
                    lang = spa  # Spanish strings
                elif self.session['session_idiom'] == "eng":
                    lang = eng  # English strings
                else:
                    lang = eng  # Default english

                all_comics = ComicBook.query()
                comics = copy.copy(all_comics)
                comics = comics.filter(ComicBook.users.username == self.
                                       session.get("session_name")).fetch()
                all_comics = all_comics.fetch()
                all_users = User.query(User.role == "client").fetch()

                # Variables to be sent to the HTML page
                values = {
                    "lang":
                    lang,  # Language strings
                    "session_name":
                    self.session.get('session_name'),  # User name
                    "session_role":
                    self.session.get('session_role'),  # User role
                    "session_picture":
                    self.get_session_image(
                        self.session.get('session_name')),  # User picture
                    "session_genre":
                    self.session.get('session_genre'),  # User genre
                    "friends":
                    friends,  # User friends
                    "requests":
                    requests,  # User friend requests
                    "all_comics":
                    all_comics,  # ALL comic (for the users search field)
                    "all_users":
                    all_users,  # ALL users (for the search field)
                    "comics":
                    comics,  # Current user comics (for the borrowinngs)
                }

                del lang, user, all, friends, requests, aux, all_comics, all_users
                self.session_store.save_sessions(
                    self.response)  # Save sessions
                self.response.write(
                    jinja.render_template(
                        "/friends/default.html",
                        **values))  # Go to the friends home page

            # Else redirect to the login page
            else:
                del user  # Delete variables to free memory
                self.redirect("/login")

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#7
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the admin is logged in
        if self.session.get('session_role') == 'admin':
            # If it's logged in, get the session variables, show the home page
            # Get the comic attributes
            author_key = self.request.get("author", "")  # Author key
            author_key = ndb.Key(urlsafe=author_key)
            role = self.request.get_all("role[]")  # Author roles

            key = self.request.get("key", "")
            key = ndb.Key(urlsafe=key)
            comic = key.get()  # Get the comic with that key

            keys_page_list = self.request.get(
                "keys_page_list",
                "")  # Comic keys (only comics in the current page)
            aux_all_keys = self.request.get(
                "all_keys", "")  # All the comic keys (for the order field)

            # Initialize variables
            aux = list()  # Support variable
            aux3 = list()  # Support variable
            all_comics = list()  # List with all comics (for the search field)

            # Transform the HTML string in a list
            all_keys = copy.copy(aux_all_keys)
            aux_all_keys = self.transform_keys(aux_all_keys)

            comics = ComicBook.query()
            for comic2 in comics:  # Get ALL the keys
                aux.append(comic2.key.urlsafe())
                del comic2

            for key3 in aux_all_keys:  # Compare the "list" given by HTML with aux for making the new all keys list (all_keys)
                for key2 in aux:
                    if key3 == str(key2):
                        key2 = ndb.Key(urlsafe=key2)
                        aux3.append(key2)
                        break
                    del key2
                del key3

            # Get all db comics
            offset = (self.session.get('current_number_page') -
                      1) * self.session.get('num_elems_page')
            comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(
                self.session.get('num_elems_page'), offset=offset)

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            # Variables to be sent to the HTML page
            values = {
                "lang":
                lang,  # Language strings
                "session_name":
                self.session.get('session_name'),  # User name
                "session_role":
                self.session.get('session_role'),  # User role
                "session_picture":
                self.get_session_image(
                    self.session.get('session_name')),  # User picture
                "session_genre":
                self.session.get('session_genre'),  # User genre
                "comics":
                comics,  # Comics
                "current_number_page":
                self.session.get('current_number_page'),  # Current number page
                "pages":
                self.session.get('pages'),  # Pages for the pagination
                "last_page":
                self.session.get('last_page'),  # Last page number
                "keys_page_list":
                keys_page_list,  # Comics keys that are currently in the page
                "all_keys":
                all_keys,  # All comic keys
                "all_comics":
                all_comics,  # ALL comic (for the search field)
                "authors":
                self.get_authors()  # Authors for adding them to the comics
            }

            # If the key is from an comic
            if comic and comic is not None and len(
                    role) > 0 and author_key is not None:
                # Adding the author
                roles = ""
                if str(role).find("all") == -1:
                    for i in range(0, len(role)):
                        roles += lang[role[i]] + ", "
                    roles = roles[:len(roles) - 2]
                    roles = roles.capitalize()
                else:
                    roles = lang["script"] + ", " + lang[
                        "drawing"] + ", " + lang["labels"] + ", " + lang[
                            "inked"] + ", " + lang["colors"] + ", " + lang[
                                "cover"]
                    roles = roles.capitalize()

                id = ComicBook_Author.query().order(
                    -ComicBook_Author.id_aux).fetch(1)
                if len(id) > 0:
                    id = id[0].id_aux + 1
                else:
                    id = 1

                comic_author = ComicBook_Author(author=author_key.get(),
                                                role=roles,
                                                id_aux=id)
                comic_author.put()

                if len(comic.authors) > 0:
                    comic.authors.append(comic_author)
                else:
                    comic.authors = [comic_author]

                aux2 = comic.put()
                time.sleep(1)

                # If the modification was successful
                if aux2 is not None:
                    # Variables to be sent to the HTML page
                    values["ok_message"] = lang[
                        "author_added_successfully"]  # Ok message (Author added successfully)

                    # Get all db Comics (Limited to the number given by the session variable [10 by default])
                    comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(
                        self.session.get('num_elems_page'), offset=offset)
                    values["comics"] = comics

                # Else show an error message
                else:
                    # Variables to be sent to the HTML page
                    values["error_message"] = lang[
                        "error_add"]  # Error message (The addition couldn't be done)

                del aux2, comic_author, roles, id  # Delete variables to free memory

            # Else show an error message
            else:
                # Values to be sent to the HTML page
                values["error_message"] = lang[
                    "must_insert_all_author_attributes"]  # Error message (You must insert all author attributes)

            all_comics = ComicBook.query().fetch(
            )  # ALL comics (for the search field)
            values["all_comics"] = all_comics

            del lang, key, comic, keys_page_list, aux_all_keys, aux, aux3, \
                all_comics, offset, all_keys, author_key, role, comics     # Delete variables to free memory
            self.session_store.save_sessions(self.response)  # Save sessions
            self.response.write(
                jinja.render_template("/comics/default.html",
                                      **values))  # Go to the comics home page

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#8
0
    def get(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the admin is logged in. If it's logged in, show the home page
        if self.session.get('session_role') == 'admin':
            # Initialize variables
            pages_to_show = self.session.get(
                'pages_to_show')  # Number of pages that shows the pagination
            pages = list(
            )  # Pages for the pagination (it's a list because of django for templates)
            self.session[
                'current_number_page'] = 1  # Session current number page
            all_keys = list()  # All comic keys
            keys_page_list = list()  # Comic keys currently in the page

            # Get all db comics (Limited to the number given by the session variable [10 by default])
            comics = ComicBook.query().order(
                -ComicBook.save_date)  # All comics ordered by save date
            all_comics = copy.copy(comics)  # ALL comics (for the search field)
            all_comics = all_comics.fetch()
            num_total = len(all_comics)  # Total number of elements

            self.session['page_name'] = "/comics"  # Current page name
            self.session['num_elems_page'] = 10  # Amount of elements

            # Get ALL the comic keys (they are necessary to do the order and filter)
            for comic in comics:
                all_keys.append(comic.key.urlsafe())
                del comic

            # If the total number of elements is above 0 do the pagination
            if num_total > 0:
                # Get the number of pages for the pagination
                num_elems_page = self.session.get(
                    'num_elems_page')  # Number of elements (comics) per page
                num_pages = num_total / num_elems_page  # Number of pages

                comics = comics.fetch(
                    self.session.get('num_elems_page'))  # Ordered by name

                # If there are less elements than session["num_elems_page"]
                if num_pages == 0:
                    num_pages = 1  # At least one page
                # Else
                else:
                    # If the rest of the division is above 0
                    if (num_total % num_elems_page) > 0:
                        num_pages = (num_total / num_elems_page
                                     ) + 1  # It's necessary other page
                    else:
                        num_pages = (num_total / num_elems_page
                                     )  # It doesn't need other page

                self.session['last_page'] = num_pages  # Last page

                # Set the pages for the pagination
                for i in range(1, num_pages + 1):
                    pages.append(i)

                # Set number of pages for the pagination (pagination only shows 3 pages)
                current_number_page = 1
                # If the current page is 1
                if current_number_page == 1:
                    pages = pages[0:pages_to_show]  # Shows pages 1,2,3
                # If the current page is the final page
                elif current_number_page == num_pages:  # Shows the last three pages
                    if (num_pages - pages_to_show) >= 0:
                        pages = pages[(num_pages - pages_to_show):]
                    else:
                        pages = pages[0:pages_to_show]
                # Else
                else:
                    pages = pages[(current_number_page - 1):(
                        current_number_page +
                        1)]  # Show the current, last and next pages

                self.session['pages'] = pages  # Pages for the pagination

                # Setting the keys list to allow the use of the "Delete page" button
                for comic in comics:
                    keys_page_list.append(comic.key.urlsafe())
                    del comic

                del num_elems_page, num_pages, current_number_page, pages  # Delete variables to free memory

            # If num_total < 0
            else:
                comics = all_comics

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            # Variables to be sent to the HTML page
            values = {
                "lang":
                lang,  # Language strings
                "session_name":
                self.session.get('session_name'),  # User name
                "session_role":
                self.session.get('session_role'),  # User role
                "session_picture":
                self.get_session_image(
                    self.session.get('session_name')),  # User picture
                "session_genre":
                self.session.get('session_genre'),  # User genre
                "comics":
                comics,  # Comics
                "current_number_page":
                1,  # Current number page
                "pages":
                self.session.get('pages'),  # Pages for the pagination
                "last_page":
                self.session.get('last_page'),  # Last page number
                "keys_page_list":
                keys_page_list,  # Comics keys that are currently in the page
                "all_keys":
                all_keys,  # All comic keys
                "all_comics":
                all_comics,  # ALL comics (for the search field)
                "authors":
                self.get_authors()  # Authors for adding them to the comics
            }

            del num_total, pages_to_show, keys_page_list, all_keys, lang, comics, all_comics  # Delete variables to free memory

            self.session_store.save_sessions(self.response)  # Save sessions
            self.response.write(
                jinja.render_template("/comics/default.html",
                                      **values))  # Go to the comics home page

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#9
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the admin is logged in
        if self.session.get('session_role') == 'admin':
            # Initialize variables
            all_keys = list()  # New comic keys list
            comics = None  # Comics list
            all_comics = list()  # ALL comics (for the search field)
            pages = list()  # Pages for the pagination

            # If it's logged in, get the session variables, show the home page
            # Get the order attributes
            order_by = self.request.get("order_by", "")  # Sort option
            order_by = order_by.encode("utf8")
            aux_all_keys = self.request.get("all_keys",
                                            "")  # All comic keys list

            if len(aux_all_keys) > 2:
                # Transform the HTML string in a list
                aux_all_keys = self.transform_keys(aux_all_keys)

                # It's necessary to compare the HTML with the query list in order to obtain the desired list, like I said
                comics = ComicBook.query()
                all_comics = copy.copy(
                    comics)  # ALL comics (for the search field)
                all_comics = all_comics.fetch()

                aux = list()
                for comic in comics:  # Get ALL the keys
                    aux.append(comic.key.urlsafe())
                    del comic

                for key in aux_all_keys:  # Compare the "list" given by HTML with aux for making the new all keys list (all_keys)
                    for key2 in aux:
                        if key == str(key2):
                            key2 = ndb.Key(urlsafe=key)
                            all_keys.append(key2)
                            break
                        del key2
                    del key

                del aux  # Delete variables to free memory

                # Get all db comics (Limited to the number given by the session variable [10 by default])
                # Not ordered because it has to respect if the comic used some ordination or filter
                comics = ComicBook.query(ComicBook.key.IN(all_keys))

            # If there is a list of comics and a sort option
            if order_by != "" and comics is not None:
                # Get the number of pages for the pagination
                num_total = len(all_keys)
                num_elems_page = self.session.get(
                    'num_elems_page')  # Number of elements (comics) per page
                num_pages = num_total / num_elems_page  # Number of pages

                if num_pages > 0:
                    # If the rest of the division is above 0
                    if (num_total % num_elems_page) > 0:
                        num_pages = (num_total / num_elems_page
                                     ) + 1  # It's necessary other page
                    else:
                        num_pages = (num_total / num_elems_page
                                     )  # It doesn't need other page

                    # Set the pages for the pagination
                    if num_pages >= self.session.get('pages_to_show'):
                        for i in range(1,
                                       self.session.get('pages_to_show') + 1):
                            pages.append(i)
                    else:
                        for i in range(1, num_pages + 1):
                            pages.append(i)

                # Order the comic list
                if order_by == "title":
                    comics = comics.order(ComicBook.title)  # Title A-Z

                    # Setting the all comic keys list
                    all_keys = list()
                    for comic in comics:
                        all_keys.append(comic.key.urlsafe())
                        del comic

                    comics = comics.fetch(self.session.get('num_elems_page'))
                elif order_by == "-title":
                    comics = comics.order(-ComicBook.title)  # Title Z-A

                    # Setting the all comic keys list
                    all_keys = list()
                    for comic in comics:
                        all_keys.append(comic.key.urlsafe())
                        del comic

                    comics = comics.fetch(self.session.get('num_elems_page'))
                elif order_by == "save_date":
                    comics = comics.order(ComicBook.save_date)  # Older first

                    # Setting the all comic keys list
                    all_keys = list()
                    for comic in comics:
                        all_keys.append(comic.key.urlsafe())
                        del comic

                    comics = comics.fetch(self.session.get('num_elems_page'))
                elif order_by == "-save_date":
                    comics = comics.order(-ComicBook.save_date)  # Newest first

                    # Setting the all comic keys list
                    all_keys = list()
                    for comic in comics:
                        all_keys.append(comic.key.urlsafe())
                        del comic

                    comics = comics.fetch(self.session.get('num_elems_page'))
                elif order_by == "value":
                    comics = comics.order(ComicBook.value)  # Value ascendant

                    # Setting the all comic keys list
                    all_keys = list()
                    for comic in comics:
                        all_keys.append(comic.key.urlsafe())
                        del comic

                    comics = comics.fetch(self.session.get('num_elems_page'))
                elif order_by == "-value":
                    comics = comics.order(-ComicBook.value)  # Value descendant

                    # Setting the all comic keys list
                    all_keys = list()
                    for comic in comics:
                        all_keys.append(comic.key.urlsafe())
                        del comic

                    comics = comics.fetch(self.session.get('num_elems_page'))
                else:
                    comics = comics.order(-ComicBook.save_date)  # Newest first

                    # Setting the all comic keys list
                    all_keys = list()
                    for comic in comics:
                        all_keys.append(comic.key.urlsafe())
                        del comic

                    comics = comics.fetch(
                        self.session.get('num_elems_page'))  # Name ascendant

                # Setting the comic keys list (only on the current page)
                keys_page_list = list()
                for comic in comics:
                    keys_page_list.append(comic.key.urlsafe())
                    del comic

                # Set the default language of the app
                if self.session['session_idiom'] == "spa":
                    lang = spa  # Spanish strings
                elif self.session['session_idiom'] == "eng":
                    lang = eng  # English strings
                else:
                    lang = eng  # Default english

                # Variables to be sent to the HTML page
                values = {
                    "lang":
                    lang,  # Language strings
                    "session_name":
                    self.session.get('session_name'),  # User name
                    "session_role":
                    self.session.get('session_role'),  # User role
                    "session_picture":
                    self.get_session_image(
                        self.session.get('session_name')),  # User picture
                    "session_genre":
                    self.session.get('session_genre'),  # User genre
                    "comics":
                    comics,  # Comics
                    "current_number_page":
                    1,  # Current number page
                    "pages":
                    pages,  # Pages for the pagination
                    "last_page":
                    self.session.get('last_page'),  # Last page number
                    "keys_page_list":
                    keys_page_list,  # Comics keys that are currently in the page
                    "all_keys":
                    all_keys,  # All comic keys
                    "all_comics":
                    all_comics,  # ALL comic (for the search field)
                    "authors":
                    self.get_authors()  # Authors for adding them to the comics
                }

                del order_by, aux_all_keys, all_keys, comics, lang, keys_page_list, pages,\
                    num_total, num_pages, num_elems_page, all_comics    # Delete variables to free memory

                self.session_store.save_sessions(
                    self.response)  # Save sessions
                self.response.write(
                    jinja.render_template(
                        "/comics/default.html",
                        **values))  # Go to the comics home page

            # Else redirect to the comics home page
            else:
                del order_by, aux_all_keys, all_keys, comics  # Delete variables to free memory
                self.redirect("/comics")

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#10
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the admin is logged in
        if self.session.get('session_role') == 'admin':
            # If it's logged in, get the session variables, show the home page
            # Get the comic attributes
            isbn = self.request.get("isbn", "")  # Comic ISBN
            isbn = isbn.encode("utf8")
            title = self.request.get("title", "")  # Comic title
            title = title.encode("utf8")
            publisher = self.request.get("publisher", "")  # Comic publisher
            publisher = publisher.encode("utf8")
            edition = self.request.get("edition", "")  # Comic edition
            edition = edition.encode("utf8")
            if edition == "":
                edition = 1
            else:
                edition = int(edition)
            edition = int(edition)
            plot = self.request.get("plot", "")  # Comic plot
            plot = plot.encode("utf8")
            type = self.request.get("type", "comic")  # Comic type
            type = type.encode("utf8")
            origin = self.request.get("origin", "other")  # Comic origin
            origin = origin.encode("utf8")
            value = self.request.get("value", "")  # Comic value
            if value == "":
                value = 0
            else:
                value = float(value)
            value = float(value)
            cover = self.request.get("cover", "")  # Comic picture
            save_date = self.request.get("save_date", "")  # Comic save date
            save_date = save_date.encode("utf8")

            keys_page_list = self.request.get(
                "keys_page_list",
                "")  # Comic keys (only comics in the current page)
            aux_all_keys = self.request.get(
                "all_keys", "")  # All the comic keys (for the order field)

            # Initialize variables
            all_keys = list()  # All the comic keys (for the order field)
            all_comics = list()  # All comics (for the search field)
            aux = list()  # Support list
            aux3 = list()  # Support list

            offset = (
                self.session.get('current_number_page') - 1
            ) * self.session.get(
                'num_elems_page')  # Number of elements to ignore in the query

            # If the current page isn't empty
            if len(keys_page_list) > 2:
                # Transform the HTML string in a list
                aux_all_keys = self.transform_keys(aux_all_keys)

                comics = ComicBook.query()
                all_comics = copy.copy(
                    comics)  # ALL comics (for the search field)
                all_comics = all_comics.fetch()

                for comic in comics:  # Get ALL the keys
                    aux.append(comic.key.urlsafe())
                    del comic

                for key in aux_all_keys:  # Compare the "list" given by HTML with aux for making the new all keys list (all_keys)
                    for key2 in aux:
                        if key == str(key2):
                            key2 = ndb.Key(urlsafe=key)
                            aux3.append(key2)
                            all_keys.append(key2.urlsafe())
                            break
                        del key2
                    del key

                # Get db comics
                comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(
                    self.session.get('num_elems_page'), offset=offset)

            # If empty
            else:
                comics = list()

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            keys_page_list = list()

            # Variables to be sent to the HTML page
            values = {
                "lang":
                lang,  # Language strings
                "session_name":
                self.session.get('session_name'),  # User name
                "session_role":
                self.session.get('session_role'),  # User role
                "session_picture":
                self.get_session_image(
                    self.session.get('session_name')),  # User picture
                "session_genre":
                self.session.get('session_genre'),  # User genre
                "comics":
                comics,  # Comics
                "current_number_page":
                self.session.get('current_number_page'),  # Current number page
                "pages":
                self.session.get('pages'),  # Pages for the pagination
                "last_page":
                self.session.get('last_page'),  # Last page number
                "keys_page_list":
                keys_page_list,  # Comic keys that are currently in the page
                "all_keys":
                all_keys,  # All comic keys
                "all_comics":
                all_comics,  # ALL comic (for the search field)
                "authors":
                self.get_authors()  # Authors for adding them to the comics
            }

            # If the user enters all the attributes (the database can have more than one comic with the same name)
            if len(title) > 0 and len(type) > 0:
                # Check the comic attributes
                if len(isbn) > 0:  # Create the ISBN string
                    isbn = isbn[0:3] + "-" + isbn[3] + "-" + isbn[
                        4:6] + "-" + isbn[6:12] + "-" + isbn[12]

                if type != "comic" or type != "manga" or type != "anthology":
                    type = "comic"

                if edition <= 0:
                    edition = 1

                if origin != "american" or origin != "european" or type != "other":
                    origin = "other"

                if cover != "":
                    cover = images.resize(cover, 300, 250)
                else:
                    cover = None

                if value < 0:
                    value = 0

                # Add the new comic to the home page
                comic = None
                if save_date != "":
                    save_date = datetime.strptime(save_date, '%Y-%m-%d')
                    comic = ComicBook(isbn=isbn,
                                      title=title,
                                      publisher=publisher,
                                      edition=edition,
                                      plot=plot,
                                      type=type,
                                      origin=origin,
                                      value=value,
                                      cover=cover,
                                      save_date=save_date)
                else:
                    comic = ComicBook(isbn=isbn,
                                      title=title,
                                      publisher=publisher,
                                      edition=edition,
                                      plot=plot,
                                      type=type,
                                      origin=origin,
                                      value=value,
                                      cover=cover)

                aux2 = comic.put()
                time.sleep(1)

                # If the comic was successfully added
                if aux2 is not None:
                    # Adding the new comic and its key to the lists
                    aux3.append(comic.key)
                    all_keys.append(comic.key.urlsafe())
                    all_comics.append(comic)

                    # Setting pagination
                    ##############################################################################################
                    pages_to_show = self.session.get(
                        'pages_to_show'
                    )  # Number of pages that shows the pagination
                    pages = list(
                    )  # Pages for the pagination (it's a list because of django for templates)

                    # Get all db comics (Limited to the number given by the session variable [10 by default])
                    comics = ComicBook.query(ComicBook.key.IN(aux3)).order(
                        -ComicBook.save_date).fetch(
                            self.session.get('num_elems_page'), offset=offset)

                    # Setting the new keys list for the comics currently in the page (allows to use the "Delete page" button)
                    for comic in comics:
                        keys_page_list.append(comic.key.urlsafe())
                        del comic

                    num_total = len(all_comics)  # Total number of elements

                    # If the total number of elements is above 0 do the pagination
                    if num_total > 0:
                        # Get the number of pages for the pagination
                        num_elems_page = self.session.get(
                            'num_elems_page'
                        )  # Number of elements (comics) per page
                        num_pages = num_total / num_elems_page  # Number of pages

                        # If there are less elements than session["num_elems_page"]
                        if num_pages == 0:
                            num_pages = 1  # At least one page
                        # Else
                        else:
                            # If the rest of the division is above 0
                            if (num_total % num_elems_page) > 0:
                                num_pages = (num_total / num_elems_page
                                             ) + 1  # It's necessary other page
                            else:
                                num_pages = (num_total / num_elems_page
                                             )  # It doesn't need other page

                        self.session['last_page'] = num_pages  # Last page

                        # Set the pages for the pagination
                        for i in range(1, num_pages + 1):
                            pages.append(i)

                        # Set number of pages for the pagination (pagination only shows 3 pages)
                        current_number_page = self.session.get(
                            'current_number_page')
                        # If the current page is 1
                        if current_number_page == 1:
                            pages = pages[0:pages_to_show]  # Shows pages 1,2,3
                        # If the current page is the final page
                        elif current_number_page == num_pages:  # Shows the last three pages
                            if (num_pages - pages_to_show) >= 0:
                                pages = pages[(num_pages - pages_to_show):]
                            else:
                                pages = pages[0:pages_to_show]
                        # Else
                        else:
                            pages = pages[(current_number_page - 2):(
                                current_number_page +
                                1)]  # Show the current, last and next pages

                        self.session[
                            'pages'] = pages  # Pages for the pagination

                        # Variables to be sent to the HTML page
                        values["comics"] = comics  # Comics
                        values["pages"] = self.session.get(
                            'pages')  # Pages for the pagination
                        values["last_page"] = self.session.get(
                            'last_page')  # Last page number

                        del num_elems_page, num_pages, current_number_page  # Delete variables to free memory
                    ###########################################################################################
                    # Variables to be sent to the HTML page
                    values["ok_message"] = lang[
                        "comic_added_successfully"]  # Ok message (comic added successfully)
                    values[
                        "keys_page_list"] = keys_page_list  # Comics keys that are currently in the page
                    values["all_keys"] = all_keys  # All comic keys
                    values[
                        "all_comics"] = all_comics  # ALL comic (for the search field)

                    del pages_to_show, pages, comics, num_total  #  Delete variables to free memory

                # If wasn't successfully added
                else:
                    del comic, aux2  # Delete variables to free memory

                    # Variables to be sent to the HTML page
                    values["error_message"] = lang[
                        "error_add"]  # Error message (The addition failed)

            # Else show an error message
            else:
                # Values to be sent to the HTML page
                values["error_message"] = lang[
                    "must_insert_all_comic_attributes"]  # Error message (You must enter all comic data)

            del lang, offset, keys_page_list, aux_all_keys, all_keys, all_comics, aux, aux3, title, \
                isbn, edition, publisher, type, origin, cover       # Delete variables to free memory
            self.session_store.save_sessions(self.response)  # Save sessions
            self.response.write(
                jinja.render_template("/comics/default.html",
                                      **values))  # Go to the comicss home page

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#11
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the admin is logged in
        if self.session.get('session_role') == 'admin' or self.session.get(
                'session_role') == 'client':
            # If it's logged in, get the session variables
            # Get the user attributes
            username = self.request.get("username", "")  # Username
            username = username.encode("utf8")
            key = self.request.get("key", "")  # User key
            key = ndb.Key(urlsafe=key)

            user = key.get()  # Get the user with that key

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            # Variables to be sent to the HTML page
            values = {
                "lang":
                lang,  # Language strings
                "session_name":
                self.session.get('session_name'),  # User name
                "session_role":
                self.session.get('session_role'),  # User role
                "session_picture":
                self.get_session_image(
                    self.session.get('session_name')),  # User picture
                "user_email":
                user.email,  # User email
                "user_key":
                user.key.urlsafe(),  # User key
                "user_genre":
                self.session.get('session_genre'),  # User genre
                "statistics":
                self.get_statistics()  # Client statistics
            }

            # If the user exists and there is an username to change
            if user is not None and len(username) > 0:
                repeated_user = User.query(User.name == username)

                # If it doesn't exist an user with the name provided
                if repeated_user.count() == 0:
                    # Set the new username
                    username_aux = copy.copy(user.name)
                    user.name = username
                    aux = user.put()
                    time.sleep(1)

                    # If the modification was successful
                    if aux is not None:
                        # Variables to be sent to the HTML page
                        # Ok message (Username modified successfully)
                        values["ok_message"] = lang[
                            "username_modified_successfully_" +
                            str(self.session.get("session_genre"))]

                        # Change the username in the comics
                        comics = ComicBook.query(
                            ComicBook.users.username == username_aux)
                        for comic in comics:
                            for user_comic in comic.users:
                                if user_comic.username == username_aux:
                                    user_comic.username = user.name
                                del user_comic
                            comic.put()
                            del comic

                        # Change the username in the User_ComicBook rows
                        user_comics = User_ComicBook.query(
                            User_ComicBook.username == username_aux)
                        for user_comic in user_comics:
                            if user_comic.username == username_aux:
                                user_comic.username = user.name
                            user_comic.put()
                            del user_comic

                        # Change the username in the shelves and shelvings
                        shelvings = Shelving.query(
                            Shelving.username == username_aux)
                        for shelving in shelvings:
                            shelving.username = user.name
                            shelving.put()
                            del shelving

                        del user_comics, shelvings  # Delete variables to free memory
                        self.session[
                            'session_name'] = user.name  # Setting the new session username
                        values["session_name"] = user.name

                    # Else show an error message
                    else:
                        # Variables to be sent to the HTML page
                        values["error_message"] = lang[
                            "error_modify"]  # Error message (The modification couldn't be done)

                    del aux, username_aux  # Delete variables to free memory

                # If already exists show an error message
                else:
                    # Values to be sent to the HTML page
                    values["error_message"] = lang[
                        "username_already_exists"]  # Error message (Username already used by other)

                del repeated_user  # Delete variables to free memory

            # Else show an error message
            else:
                # Values to be sent to the HTML page
                # Error message (Username couldn't be modified)
                values["error_message"] = lang[
                    "username_not_modified_" +
                    str(self.session.get("session_genre"))]

            del lang, username, key, user  # Delete variables to free memory
            self.session_store.save_sessions(self.response)  # Save sessions
            self.response.write(
                jinja.render_template("/profile/default.html",
                                      **values))  # Go to the profile home page

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#12
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in. If it's logged in, show the home page
        if self.session.get('session_role') == 'client':
            user = User.query(User.name == self.session.get("session_name")).fetch()        # Current user
            # Get the friend id
            who_ask = self.request.get("who_ask", "")

            # If users exists, get friends and friends requests
            if user and len(user) > 0:
                user = user[0]
                # Get db friends and friend requests
                all = Friend.query().order(-Friend.addition_date)

                # Db friends
                friends = copy.copy(all)
                friends = friends.filter(Friend.is_friend == True)
                friends = friends.filter(ndb.OR(Friend.who_ask == user.key, Friend.who_answer == user.key))
                friends = friends.order(-Friend.addition_date)
                aux = list()
                for friend in friends:
                    if friend.who_answer != user.key:
                        aux.append(friend.who_answer.get())
                    elif friend.who_ask != user.key:
                        aux.append(friend.who_ask.get())
                    del friend
                friends = aux

                # Db friends requests
                requests = copy.copy(all)
                requests = requests.filter(Friend.is_friend == False)
                requests = requests.filter(Friend.who_answer == user.key)
                requests = requests.order(-Friend.addition_date)
                aux = list()
                for request in requests:
                    aux.append(request.who_ask.get())
                    del request
                requests = aux

                # Set the default language of the app
                if self.session['session_idiom'] == "spa":
                    lang = spa  # Spanish strings
                elif self.session['session_idiom'] == "eng":
                    lang = eng  # English strings
                else:
                    lang = eng  # Default english

                all_comics = ComicBook.query()
                comics = copy.copy(all_comics)
                comics = comics.filter(ComicBook.users.username == self.session.get("session_name")).fetch()
                all_comics = all_comics.fetch()
                all_users = User.query(User.role == "client").fetch()

                # Variables to be sent to the HTML page
                values = {
                    "lang": lang,                                                                   # Language strings
                    "session_name": self.session.get('session_name'),                               # User name
                    "session_role": self.session.get('session_role'),                               # User role
                    "session_picture": self.get_session_image(self.session.get('session_name')),    # User picture
                    "session_genre": self.session.get('session_genre'),                             # User genre
                    "friends": friends,                                                             # User friends
                    "requests": requests,                                                           # User friend requests
                    "all_comics": all_comics,                                                       # ALL comic (for the users search field)
                    "all_users": all_users,                                                         # ALL users (for the search field)
                    "comics": comics,                                                               # Current user comics (for the borrowinngs)
                }

                # If the key is valid
                if len(who_ask) > 0:
                    who_ask = ndb.Key(urlsafe=who_ask)  # Friend who's going to be deleted
                    who_ask = who_ask.get()

                    # If user exists
                    if who_ask != None:
                        # Delete the friend
                        aux = True
                        requests2 = copy.copy(all)
                        requests2 = requests2.filter(ndb.OR(Friend.who_answer == user.key, Friend.who_ask == user.key))
                        for request in requests2:
                            if request.who_ask == who_ask.key and request.who_answer == user.key and request.is_friend == True:
                                request.key.delete()
                                aux = False
                            elif request.who_ask == who_ask.key and request.who_answer == user.key and request.is_friend == False:
                                request.key.delete()
                            if request.who_ask == user.key and request.who_answer == who_ask.key and request.is_friend == True:
                                request.key.delete()
                                aux = False
                            elif request.who_ask == user.key and request.who_answer == who_ask.key and request.is_friend == False:
                                request.key.delete()

                            del request

                        if who_ask in requests:
                            requests.remove(who_ask)    # Remove user from the request list
                        if who_ask in friends:
                            friends.remove(who_ask)     # Add user to the friend list

                        # Values to be sent to the HTML page
                        values["friends"] = friends
                        values["requests"] = requests
                        if aux == True:
                            values["ok_message"] = lang["request_deleted_successfully"] + " " + str(who_ask.name)     # Request deleted successfully
                        else:
                            values["ok_message"] = lang["friend_deleted_successfully"] + " " + str(who_ask.name)  # Friend deleted successfully

                        del requests2  # Delete variables to free memory

                    # Else show an error message
                    else:
                        values["error_message"] = lang["error_delete"]  # The deleting couldn't be done

                # Else show an error message
                else:
                    values["error_message"] = lang["friend_not_deleted"]    # Friend couldn't be deleted

                del lang, user, all, friends, requests, aux, all_comics, all_users, who_ask
                self.session_store.save_sessions(self.response)  # Save sessions
                self.response.write(jinja.render_template("/friends/default.html", **values))  # Go to the friends home page

            # Else redirect to the login page
            else:
                del user        # Delete variables to free memory
                self.redirect("/login")

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#13
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # If an admin is logged in delete the comic
        if self.session.get('session_role') == 'admin':
            # Retrieving the comic key
            id = self.request.get("id", "")
            comic_author = list()
            if id != "":
                id = int(id)
                comic_author = ComicBook_Author.query(
                    ComicBook_Author.id_aux == id).fetch(
                        1)  # Get the author row in the ComicBook_Author table

            key = self.request.get("key", "")
            key = ndb.Key(urlsafe=key)
            comic = key.get()  # Get the db comic with that key

            keys_page_list = self.request.get(
                "keys_page_list",
                "")  # Comic keys (only comics in the current page)
            aux_all_keys = self.request.get(
                "all_keys", "")  # All the comic keys (for the order field)

            # Initialize variables
            all_keys = list()  # All the comic keys (for the order field)
            aux = list()  # Support variable
            aux3 = list()  # Support variable

            # Transform the HTML string in a list
            aux_all_keys = self.transform_keys(aux_all_keys)

            comics = ComicBook.query()
            all_comics = copy.copy(comics)  # ALL comics (for the search field)
            all_comics = all_comics.fetch()

            for comic2 in comics:  # Get ALL the keys
                aux.append(comic2.key.urlsafe())
                del comic2

            for key3 in aux_all_keys:  # Compare the "list" given by HTML with aux for making the new all keys list (all_keys)
                for key2 in aux:
                    if key3 == str(key2):
                        key2 = ndb.Key(urlsafe=key2)
                        aux3.append(key2)
                        all_keys.append(key2.urlsafe())
                        break
                    del key2
                del key3

            # Get db comics
            offset = (self.session.get('current_number_page') -
                      1) * self.session.get('num_elems_page')
            comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(
                self.session.get('num_elems_page'), offset=offset)

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            # Variables to be sent to the HTML page
            values = {
                "lang":
                lang,  # Language strings
                "session_name":
                self.session.get('session_name'),  # User name
                "session_role":
                self.session.get('session_role'),  # User role
                "session_picture":
                self.get_session_image(
                    self.session.get('session_name')),  # User picture
                "session_genre":
                self.session.get('session_genre'),  # User genre
                "comics":
                comics,  # Comics
                "current_number_page":
                self.session.get('current_number_page'),  # Current number page
                "pages":
                self.session.get('pages'),  # Pages for the pagination
                "last_page":
                self.session.get('last_page'),  # Last page number
                "keys_page_list":
                keys_page_list,  # Comics keys that are currently in the page
                "all_keys":
                all_keys,  # All comic keys
                "all_comics":
                all_comics,  # ALL comic (for the search field)
                "authors":
                self.get_authors()  # Authors for adding them to the comics
            }

            # If the author exists
            if comic and comic is not None and len(comic_author) > 0:
                # Delete the association in the ComicBook class
                for i in range(0, len(comic.authors)):
                    if comic.authors[i].id_aux == comic_author[0].id_aux:
                        comic.authors.pop(i)
                        break
                    del i
                comic.put()
                # Delete the ComicBook_Author bd row
                comic_author[0].key.delete()

                values["ok_message"] = lang[
                    "author_deleted_successfully"]  # Ok message (author deleted successfully)

                # Setting pagination
                ##############################################################################################
                pages_to_show = self.session.get(
                    'pages_to_show'
                )  # Number of pages that shows the pagination
                pages = list(
                )  # Pages for the pagination (it's a list because of django for templates)

                # Get all db comics (Limited to the number given by the session variable [10 by default])
                num_total = len(aux3)  # Total number of elements
                if len(aux3) > 0:
                    comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(
                        self.session.get('num_elems_page'),
                        offset=offset)  # List not empty
                else:
                    comics = list()

                # If the total number of elements is above 0 do the pagination
                if num_total > 0 and len(comics) > 0:
                    # Get the number of pages for the pagination
                    num_elems_page = self.session.get(
                        'num_elems_page'
                    )  # Number of elements (comics) per page
                    num_pages = num_total / num_elems_page  # Number of pages

                    # If there are less elements than session["num_elems_page"]
                    if num_pages == 0:
                        num_pages = 1  # At least one page
                    # Else
                    else:
                        # If the rest of the division is above 0
                        if (num_total % num_elems_page) > 0:
                            num_pages = (num_total / num_elems_page
                                         ) + 1  # It's necessary other page
                        else:
                            num_pages = (num_total / num_elems_page
                                         )  # It doesn't need other page

                    self.session['last_page'] = num_pages  # Last page

                    # Set the pages for the pagination
                    for i in range(1, num_pages + 1):
                        pages.append(i)

                    # Set number of pages for the pagination (pagination only shows 3 pages)
                    current_number_page = self.session.get(
                        'current_number_page')
                    # If the current page is 1
                    if current_number_page == 1:
                        pages = pages[0:pages_to_show]  # Shows pages 1,2,3
                    # If the current page is the final page
                    elif current_number_page == num_pages:  # Shows the last three pages
                        if (num_pages - pages_to_show) >= 0:
                            pages = pages[(num_pages - pages_to_show):]
                        else:
                            pages = pages[0:pages_to_show]
                    # Else
                    else:
                        pages = pages[(current_number_page - 2):(
                            current_number_page +
                            1)]  # Show the current, last and next pages

                    self.session['pages'] = pages  # Pages for the pagination

                    del num_elems_page, num_pages, current_number_page  # Delete variables to free memory

                # If page is empty do the same, but return to the to the last page next to the current page
                elif num_total > 0 and len(comics) == 0:
                    # Get all db comics (Limited to the number given by the session variable [10 by default])
                    offset = (self.session.get('current_number_page') -
                              2) * self.session.get('num_elems_page')
                    comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(
                        self.session.get('num_elems_page'), offset=offset)

                    # Get the number of pages for the pagination
                    num_elems_page = self.session.get(
                        'num_elems_page'
                    )  # Number of elements (comics) per page
                    num_pages = num_total / num_elems_page  # Number of pages

                    # If there are less elements than session["num_elems_page"]
                    if num_pages == 0:
                        num_pages = 1  # At least one page
                    # Else
                    else:
                        # If the rest of the division is above 0
                        if (num_total % num_elems_page) > 0:
                            num_pages = (num_total / num_elems_page
                                         ) + 1  # It's necessary other page
                        else:
                            num_pages = (num_total / num_elems_page
                                         )  # It doesn't need other page

                    current_number_page = num_pages  # The previous last page doesn't already exist, so it has to be the last page of the new list
                    self.session['last_page'] = num_pages  # Last page

                    # Set the pages for the pagination
                    for i in range(1, num_pages + 1):
                        pages.append(i)

                    # Set number of pages for the pagination (pagination only shows 3 pages)
                    # If the current page is 1
                    if current_number_page == 1:
                        pages = pages[0:pages_to_show]  # Shows pages 1,2,3
                    # If the current page is the final page
                    elif current_number_page == num_pages:  # Shows the last three pages
                        if (num_pages - pages_to_show) >= 0:
                            pages = pages[(num_pages - pages_to_show):]
                        else:
                            pages = pages[0:pages_to_show]
                    # Else
                    else:
                        pages = pages[(current_number_page - 2):(
                            current_number_page +
                            1)]  # Show the current, last and next pages

                    self.session['pages'] = pages  # Pages for the pagination
                    self.session[
                        'current_number_page'] = current_number_page  # Current number page

                    del num_elems_page, num_pages, current_number_page  # Delete variables to free memory
                ###########################################################################################

                # Variables to be sent to the html
                values["comics"] = comics  # Comics
                values["pages"] = self.session.get(
                    'pages')  # Pages for the pagination
                values["last_page"] = self.session.get(
                    'last_page')  # Last page number
                values["all_keys"] = all_keys  # All comic keys
                values["current_number_page"] = self.session.get(
                    'current_number_page')  # Current number page

                # Setting the all comics list
                all_comics = ComicBook.query().fetch()
                values["all_comics"] = all_comics

                # Setting the comic keys list that are currently in the page
                keys_page_list = list()
                for comic in comics:
                    keys_page_list.append(comic.key.urlsafe())
                values["keys_page_list"] = keys_page_list

                del pages_to_show, pages, num_total  # Delete variables to free memory

            # Else show an error message
            else:
                values["error_message"] = lang[
                    "author_not_deleted"]  # Error message (Author couldn't be deleted)

            del id, keys_page_list, aux_all_keys, all_keys, aux, aux3, all_comics, offset, comics,\
                lang, key, comic, comic_author  # Delete variables to free memory
            self.session_store.save_sessions(self.response)  # Save sessions
            self.response.write(
                jinja.render_template("/comics/default.html",
                                      **values))  # Go to the comics home page

        # Else redirect to the login page
        else:
            self.redirect("/login")
示例#14
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in. If it's logged in, show the home page
        if self.session.get('session_role') == 'client':
            user = User.query(User.name == self.session.get("session_name")).fetch()        # Current user

            # If users exists, get friends and friends requests
            if user and len(user) > 0:
                user = user[0]
                # Get db friends and friend requests
                all = Friend.query().order(-Friend.addition_date)

                # Db friends
                friends = copy.copy(all)
                friends = friends.filter(Friend.is_friend == True)
                friends = friends.filter(ndb.OR(Friend.who_ask == user.key, Friend.who_answer == user.key))
                friends = friends.order(-Friend.addition_date)
                aux = list()
                for friend in friends:
                    if friend.who_answer != user.key:
                        aux.append(friend.who_answer.get())
                    elif friend.who_ask != user.key:
                        aux.append(friend.who_ask.get())
                    del friend
                friends = aux

                # Db friends requests
                requests = copy.copy(all)
                requests = requests.filter(Friend.is_friend == False)
                requests = requests.filter(Friend.who_answer == user.key)
                requests = requests.order(-Friend.addition_date)
                aux = list()
                for request in requests:
                    aux.append(request.who_ask.get())
                    del request
                requests = aux

                # Set the default language of the app
                if self.session['session_idiom'] == "spa":
                    lang = spa  # Spanish strings
                elif self.session['session_idiom'] == "eng":
                    lang = eng  # English strings
                else:
                    lang = eng  # Default english

                all_comics = ComicBook.query()
                comics = copy.copy(all_comics)
                comics = comics.filter(ComicBook.users.username == self.session.get("session_name")).fetch()
                all_comics = all_comics.fetch()
                all_users = User.query(User.role == "client").fetch()

                # Variables to be sent to the HTML page
                values = {
                    "lang": lang,                                                                   # Language strings
                    "session_name": self.session.get('session_name'),                               # User name
                    "session_role": self.session.get('session_role'),                               # User role
                    "session_picture": self.get_session_image(self.session.get('session_name')),    # User picture
                    "session_genre": self.session.get('session_genre'),                             # User genre
                    "friends": friends,                                                             # User friends
                    "requests": requests,                                                           # User friend requests
                    "all_comics": all_comics,                                                       # ALL comic (for the users search field)
                    "all_users": all_users,                                                         # ALL users (for the search field)
                    "comics": comics,                                                               # Current user comics (for the borrowinngs)
                }

                friend = self.request.get("friend", "")         # Friend
                comic = self.request.get("comic_key", "")       # Comic

                # If the friend is valid
                if len(friend) > 0 and len(comic) > 0:
                    friend = ndb.Key(urlsafe=friend)
                    comic = ndb.Key(urlsafe=comic)
                    friend = friend.get()
                    comic = comic.get()

                    # If user exists
                    if friend is not None and comic is not None:
                        borrowing = Borrowing.query(Borrowing.who_want == friend.key, Borrowing.who_borrow == user.key, Borrowing.comic == comic.key).fetch()

                        # If the comic wasn't already borrowed to this user
                        if len(borrowing) == 0:
                            # Add a new borrowing
                            borrowing = Borrowing(who_want=friend.key, who_borrow=user.key, is_borrowed=True, comic=comic.key)
                            borrowing = borrowing.put()

                            # If the adding was successful
                            if borrowing is not None:
                                values["ok_message"] = lang["borrowing_added_successfully"] + " " + str(friend.name)  # Borrowing added successfully

                            # Else show an error message
                            else:
                                values["error_message"] = lang["error_add"]

                        # Else do nothing
                        else:
                            values["ok_message"] = lang["borrowing_already_added"] + " " + str(friend.name)  # Borrowing already added

                        del borrowing  # Delete variables to free memory

                    # Else show an error message
                    else:
                        values["error_message"] = lang["error_add"]  # The adding couldn't be done

                # Else show an error message
                else:
                    values["error_message"] = lang["borrowing_not_added"]    # Borrowing couldn't be added

                del lang, user, all, friends, requests, aux, all_comics, all_users, friend, comic
                self.session_store.save_sessions(self.response)  # Save sessions
                self.response.write(jinja.render_template("/friends/default.html", **values))  # Go to the friends home page

            # Else redirect to the login page
            else:
                del user        # Delete variables to free memory
                self.redirect("/login")

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#15
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in. If it's logged in, show the home page
        if self.session.get('session_role') == 'client':
            user = User.query(User.name == self.session.get(
                "session_name")).fetch()  # Current user
            # Get the friend id
            friend = self.request.get("friend", "")  # Friend

            # If users exists, get friends and friends requests
            if user and len(user) > 0:
                user = user[0]
                all = Friend.query().order(-Friend.addition_date)

                # Db friends
                friends = copy.copy(all)
                friends = friends.filter(Friend.is_friend == True)
                friends = friends.filter(
                    ndb.OR(Friend.who_ask == user.key,
                           Friend.who_answer == user.key))
                friends = friends.order(-Friend.addition_date)
                aux = list()
                for friend2 in friends:
                    if friend2.who_answer != user.key:
                        aux.append(friend2.who_answer.get())
                    elif friend2.who_ask != user.key:
                        aux.append(friend2.who_ask.get())
                    del friend2
                friends = aux

                # Db friends requests
                requests = copy.copy(all)
                requests = requests.filter(Friend.is_friend == False)
                requests = requests.filter(Friend.who_answer == user.key)
                requests = requests.order(-Friend.addition_date)
                aux = list()
                for request in requests:
                    aux.append(request.who_ask.get())
                    del request
                requests = aux

                # Set the default language of the app
                if self.session['session_idiom'] == "spa":
                    lang = spa  # Spanish strings
                elif self.session['session_idiom'] == "eng":
                    lang = eng  # English strings
                else:
                    lang = eng  # Default english

                all_comics = ComicBook.query()
                comics = copy.copy(all_comics)
                comics = comics.filter(ComicBook.users.username == self.
                                       session.get("session_name")).fetch()
                all_comics = all_comics.fetch()
                all_users = User.query(User.role == "client").fetch()

                # Variables to be sent to the HTML page
                values = {
                    "lang":
                    lang,  # Language strings
                    "session_name":
                    self.session.get('session_name'),  # User name
                    "session_role":
                    self.session.get('session_role'),  # User role
                    "session_picture":
                    self.get_session_image(
                        self.session.get('session_name')),  # User picture
                    "session_genre":
                    self.session.get('session_genre'),  # User genre
                    "friends":
                    friends,  # User friends
                    "requests":
                    requests,  # User friend requests
                    "all_comics":
                    all_comics,  # ALL comic (for the users search field)
                    "all_users":
                    all_users,  # ALL users (for the search field)
                    "comics":
                    comics,  # Current user comics (for the borrowinngs)
                }

                # If the key is valid
                if len(friend) > 0:
                    friend = ndb.Key(
                        urlsafe=friend)  # User who made the friend request
                    friend = friend.get()

                    # If user exists
                    if friend != None:
                        collection = ComicBook.query(
                            ComicBook.users.username == friend.name).order(
                                ComicBook.title)  # Friend collection

                        # Variables to be sent to the HTML page
                        values = {
                            "lang":
                            lang,  # Language strings
                            "session_name":
                            self.session.get('session_name'),  # User name
                            "session_role":
                            self.session.get('session_role'),  # User role
                            "session_picture":
                            self.get_session_image(
                                self.session.get(
                                    'session_name')),  # User picture
                            "session_genre":
                            self.session.get('session_genre'),  # User genre
                            "all_comics":
                            all_comics,  # ALL comic (for the users search field)
                            "collection":
                            collection,  # Friend collection
                            "friend":
                            friend  # Friend
                        }

                        del lang, user, all, friends, requests, aux, all_comics, all_users, friend, collection  # Delete variables to free memory
                        self.session_store.save_sessions(
                            self.response)  # Save sessions
                        self.response.write(
                            jinja.render_template(
                                "/friends/collection.html",
                                **values))  # Go to the collection page

                    # Else show an error message
                    else:
                        del lang, user, all, friends, requests, aux, all_comics, all_users, friend
                        values["error_message"] = lang[
                            "friend_not_collection2"]  # There was a problem showing the user collection
                        self.session_store.save_sessions(
                            self.response)  # Save sessions
                        self.response.write(
                            jinja.render_template(
                                "/friends/default.html",
                                **values))  # Go to the friends home page

                # Else show an error message
                else:
                    del lang, user, all, friends, requests, aux, all_comics, all_users, friend
                    values["error_message"] = lang[
                        "friend_not_collection"]  # Collection couldn't be shown
                    self.session_store.save_sessions(
                        self.response)  # Save sessions
                    self.response.write(
                        jinja.render_template(
                            "/friends/default.html",
                            **values))  # Go to the friends home page

            # Else redirect to the login page
            else:
                del user  # Delete variables to free memory
                self.redirect("/login")

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#16
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in. If it's logged in, add a borrowing
        if self.session.get('session_role') == 'client':
            user = User.query(User.name == self.session.get(
                "session_name")).fetch()  # Current user

            # If users exists, get borrowings
            if user and len(user) > 0:
                user = user[0]
                # Get db borrowings
                all = Borrowing.query()

                # Db borrowed comics
                borrow_comics = copy.copy(all)
                borrow_comics = borrow_comics.filter(
                    Borrowing.is_borrowed == True)
                borrow_comics = borrow_comics.filter(
                    Borrowing.who_borrow == user.key)
                aux = list()
                for borrow_comic in borrow_comics:
                    aux2 = borrow_comic.comic.get()
                    aux3 = borrow_comic.who_want.get()
                    aux2.owner_name = aux3.name
                    aux.append(aux2)
                    del borrow_comic, aux2, aux3
                borrow_comics = aux

                # Db asked comics
                orders = copy.copy(all)
                orders = orders.filter(Borrowing.is_borrowed == False)
                orders = orders.filter(Borrowing.who_borrow == user.key)
                aux = list()
                for order in orders:
                    aux2 = order.comic.get()
                    aux3 = order.who_want.get()
                    aux2.owner_name = aux3.name
                    aux.append(aux2)
                    del order, aux2, aux3
                orders = aux

                # Db comics that user ask for
                own = copy.copy(all)
                own = own.filter(Borrowing.is_borrowed == True)
                own = own.filter(Borrowing.who_want == user.key)
                aux = list()
                for elem in own:
                    aux2 = elem.comic.get()
                    aux3 = elem.who_borrow.get()
                    aux2.owner_name = aux3.name
                    aux.append(aux2)
                    del elem, aux2, aux3
                own = aux

                # Set the default language of the app
                if self.session['session_idiom'] == "spa":
                    lang = spa  # Spanish strings
                elif self.session['session_idiom'] == "eng":
                    lang = eng  # English strings
                else:
                    lang = eng  # Default english

                all_comics = ComicBook.query().fetch()

                # Variables to be sent to the HTML page
                values = {
                    "lang":
                    lang,  # Language strings
                    "session_name":
                    self.session.get('session_name'),  # User name
                    "session_role":
                    self.session.get('session_role'),  # User role
                    "session_picture":
                    self.get_session_image(
                        self.session.get('session_name')),  # User picture
                    "session_genre":
                    self.session.get('session_genre'),  # User genre
                    "borrow_comics":
                    borrow_comics,  # Borrowed comics
                    "orders":
                    orders,  # Asked comics
                    "own":
                    own,  # Comics that current user ask for
                    "all_comics":
                    all_comics,  # ALL comic (for the users search field)
                }

                friend = self.request.get("friend_name", "")  # Friend
                friend = User.query(User.name == friend).fetch()
                comic = self.request.get("comic_key", "")  # Comic

                # If the friend is valid
                if len(friend) > 0 and len(comic) > 0:
                    friend = friend[0]
                    comic = ndb.Key(urlsafe=comic)
                    comic = comic.get()

                    # If user exists
                    if friend is not None and comic is not None:
                        # Add a new borrowing
                        borrowing = Borrowing.query(
                            Borrowing.who_want == friend.key,
                            Borrowing.who_borrow == user.key,
                            Borrowing.comic == comic.key).fetch()

                        # If the borrowing exists
                        if len(borrowing) > 0:
                            # If the adding was successful
                            if borrowing is not None:
                                borrowing = borrowing[0]
                                borrowing.is_borrowed = True
                                borrowing.put()
                                time.sleep(1)

                                comic = borrowing.comic.get()
                                # Update lists
                                if borrowing in orders:
                                    orders.remove(comic)
                                comic.owner_name = friend.name
                                borrow_comics.append(comic)

                                # Values to be sent to the HTML page
                                values["orders"] = orders
                                values["borrow_comics"] = borrow_comics
                                values["ok_message"] = lang[
                                    "borrowing_added_successfully"] + " " + str(
                                        friend.name
                                    )  # Borrowing added successfully

                            # Else
                            else:
                                values["error_message"] = lang["error_add"]

                        # Else show an error message
                        else:
                            values["error_message"] = lang[
                                "error_add"]  # The adding couldn't be done

                        del borrowing  # Delete variables to free memory

                    # Else show an error message
                    else:
                        values["error_message"] = lang[
                            "error_add"]  # The adding couldn't be done

                # Else show an error message
                else:
                    values["error_message"] = lang[
                        "borrowing_not_added"]  # Borrowing couldn't be added

                del lang, user, all, borrow_comics, orders, aux, all_comics, own, friend, comic
                self.session_store.save_sessions(
                    self.response)  # Save sessions
                self.response.write(
                    jinja.render_template(
                        "/borrowings/default.html",
                        **values))  # Go to the borrowings home page

            # Else redirect to the login page
            else:
                del user  # Delete variables to free memory
                self.redirect("/login")

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#17
0
    def get(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in. If it's logged in, show the home page
        if self.session.get('session_role') == 'client':
            # Initialize variables
            pages_to_show = self.session.get(
                'pages_to_show')  # Number of pages that shows the pagination
            pages = list(
            )  # Pages for the pagination (it's a list because of django for templates)
            self.session[
                'current_number_page'] = 1  # Session current number page
            all_keys = list()  # All comic keys
            keys_page_list = list()  # Comic keys currently in the page
            shelving_name = list()  # Shelving name

            self.session['num_elems_page'] = 12  # Amount of elements

            # Get all comics that belongs to the current user
            if not self.session.get("shelving"):
                comics = ComicBook.query(
                    ComicBook.users.username ==
                    self.session.get('session_name')).order(
                        ComicBook.users.addition_date
                    )  # All comics ordered by the addition date
                all_comics_user = copy.copy(
                    comics)  # ALL comics (for the search field)
                all_comics_user = all_comics_user.fetch()
            else:
                key = ndb.Key(urlsafe=self.session.get("shelving"))
                comics = ComicBook.query(
                    ComicBook.users.username == self.session.get(
                        'session_name'),
                    ComicBook.users.shelving == key).order(
                        ComicBook.users.addition_date
                    )  # Comics in the shelving ordered by the addition date
                shelving = key.get()
                shelving_name = shelving.name
                del shelving
                all_comics_user = ComicBook.query(
                    ComicBook.users.username == self.session.get(
                        'session_name')).fetch(
                        )  # ALL comics (for the search field)

            # Get ALL the comic keys (they are necessary to do the order and filter)
            for comic in comics:
                all_keys.append(comic.key.urlsafe())
                del comic

            # Number of comics shown in the page
            comics = comics.fetch(12)
            # Get the comics (if --> default, else --> see shelving)
            if not self.session.get('shelving'):
                comics = self.get_comics_read_and_without_shelving(
                    comics
                )  # Get read comics and the ones that aren't in a shelving
            else:
                self.get_comics_read(comics)  # Get read comics

            num_total = len(all_comics_user)  # Total number of elements

            # Get the shelvings
            shelvings = Shelving.query(
                Shelving.username == self.session.get('session_name')).order(
                    Shelving.name).fetch()

            self.session['page_name'] = "/library"  # Current page name

            # If the total number of elements is above 0 do the pagination
            if num_total > 0:
                # Get the number of pages for the pagination
                num_elems_page = self.session.get(
                    "num_elems_page")  # Number of elements (comics) per page
                num_pages = num_total / num_elems_page  # Number of pages

                # If there are less elements than session["num_elems_page"]
                if num_pages == 0:
                    num_pages = 1  # At least one page
                # Else
                else:
                    # If the rest of the division is above 0
                    if (num_total % num_elems_page) > 0:
                        num_pages = (num_total / num_elems_page
                                     ) + 1  # It's necessary other page
                    else:
                        num_pages = (num_total / num_elems_page
                                     )  # It doesn't need other page

                self.session['last_page'] = num_pages  # Last page

                # Set the pages for the pagination
                for i in range(1, num_pages + 1):
                    pages.append(i)

                # Set number of pages for the pagination (pagination only shows 3 pages)
                current_number_page = 1
                # If the current page is 1
                if current_number_page == 1:
                    pages = pages[0:pages_to_show]  # Shows pages 1,2,3
                # If the current page is the final page
                elif current_number_page == num_pages:  # Shows the last three pages
                    if (num_pages - pages_to_show) >= 0:
                        pages = pages[(num_pages - pages_to_show):]
                    else:
                        pages = pages[0:pages_to_show]
                # Else
                else:
                    pages = pages[(current_number_page - 1):(
                        current_number_page +
                        1)]  # Show the current, last and next pages

                self.session['pages'] = pages  # Pages for the pagination

                # Setting the keys list to allow the use of the "Delete page" button
                for comic in comics:
                    keys_page_list.append(comic.key.urlsafe())
                    del comic

                del num_elems_page, num_pages, current_number_page, pages  # Delete variables to free memory

            # If num_total < 0
            else:
                comics = all_comics_user

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            all_comics = ComicBook.query().fetch()

            # Variables to be sent to the HTML page
            values = {
                "lang":
                lang,  # Language strings
                "session_name":
                self.session.get('session_name'),  # User name
                "session_role":
                self.session.get('session_role'),  # User role
                "session_picture":
                self.get_session_image(
                    self.session.get('session_name')),  # User picture
                "session_genre":
                self.session.get('session_genre'),  # User genre
                "comics":
                comics,  # Comics
                "current_number_page":
                1,  # Current number page
                "pages":
                self.session.get('pages'),  # Pages for the pagination
                "last_page":
                self.session.get('last_page'),  # Last page number
                "keys_page_list":
                keys_page_list,  # Comics keys that are currently in the page
                "all_keys":
                all_keys,  # All comic keys
                "all_comics_user":
                all_comics_user,  # All user comics (for the search field)
                "all_comics":
                all_comics,  # ALL comics (for the user search field)
                "shelvings":
                shelvings,  # All user shelvings
                "shelving_name":
                shelving_name  # Shelving name
            }

            del num_total, pages_to_show, keys_page_list, all_keys, lang, comics, all_comics_user, all_comics, shelving_name  # Delete variables to free memory

            self.session_store.save_sessions(self.response)  # Save sessions
            self.response.write(
                jinja.render_template("/library/default.html",
                                      **values))  # Go to the library home page

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#18
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in
        if self.session.get('session_role') == 'client':
            # If it's logged in, get the session variables, show the home page
            # Get the comic attributes
            name = self.request.get("m_name", "")                     # Shelving name
            name = name.encode("utf8")
            picture = self.request.get("m_picture", "")               # Shelving picture

            key = self.request.get("key", "")
            key = ndb.Key(urlsafe=key)
            shelving = key.get()      # Get the shelving with that key

            keys_page_list = self.request.get("keys_page_list", "")     # Comic keys (only comics in the current page)
            aux_all_keys = self.request.get("all_keys", "")             # All the comic keys (for the order field)

            # Initialize variables
            aux = list()              # Support variable
            aux3 = list()             # Support variable
            all_comics = list()       # List with all comics (for the search field)
            shelving_name = list()    # Shelving name

            # Get the user shelvings
            shelvings = Shelving.query(Shelving.username == self.session.get("session_name")).order(Shelving.name).fetch()

            # Transform the HTML string in a list
            all_keys = copy.copy(aux_all_keys)
            aux_all_keys = self.transform_keys(aux_all_keys)

            # Get all comics that belongs to the current user
            if not self.session.get("shelving"):
                comics = ComicBook.query(ComicBook.users.username == self.session.get('session_name')).order(ComicBook.users.addition_date)  # All comics ordered by the addition date
                all_comics_user = copy.copy(comics)  # ALL comics (for the search field)
                all_comics_user = all_comics_user.fetch()
            else:
                key = ndb.Key(urlsafe=self.session.get("shelving"))
                comics = ComicBook.query(ComicBook.users.username == self.session.get('session_name'),ComicBook.users.shelving == key).order(ComicBook.users.addition_date)  # Comics in the shelving ordered by the addition date
                shelving2 = key.get()
                shelving_name = shelving2.name
                del shelving2
                all_comics_user = ComicBook.query(ComicBook.users.username == self.session.get('session_name')).fetch()  # ALL comics (for the search field)

            for comic2 in comics:  # Get ALL the keys
                aux.append(comic2.key.urlsafe())
                del comic2

            for key3 in aux_all_keys:  # Compare the "list" given by HTML with aux for making the new all keys list (all_keys)
                for key2 in aux:
                    if key3 == str(key2):
                        key2 = ndb.Key(urlsafe=key2)
                        aux3.append(key2)
                        break
                    del key2
                del key3

            # Get all db comics
            offset = (self.session.get('current_number_page') - 1) * self.session.get('num_elems_page')
            if len(aux3) > 0:
                comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(self.session.get('num_elems_page'), offset=offset)
                # Get the comics (if --> default, else --> see shelving)
                if not self.session.get('shelving'):
                    comics = self.get_comics_read_and_without_shelving(comics)  # Get read comics and the ones that aren't in a shelving
                else:
                    self.get_comics_read(comics)  # Get read comics
            else:
                comics = list()

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            # Variables to be sent to the HTML page
            values = {
                "lang": lang,                                                                   # Language strings
                "session_name": self.session.get('session_name'),                               # User name
                "session_role": self.session.get('session_role'),                               # User role
                "session_picture": self.get_session_image(self.session.get('session_name')),    # User picture
                "session_genre": self.session.get('session_genre'),                             # User genre
                "comics": comics,                                                               # Comics
                "current_number_page": self.session.get('current_number_page'),                 # Current number page
                "pages": self.session.get('pages'),                                             # Pages for the pagination
                "last_page": self.session.get('last_page'),                                     # Last page number
                "keys_page_list": keys_page_list,                                               # Comics keys that are currently in the page
                "all_keys": all_keys,                                                           # All comic keys
                "all_comics": all_comics,                                                       # ALL comic (for the user search field)
                "authors": self.get_authors(),                                                  # Authors for adding them to the comics
                "all_comics_user": all_comics_user,                                             # All user comics (for the user search field)
                "shelvings": shelvings,                                                         # Shelvings
                "shelving_name": shelving_name                                                  # Shelving name
            }

            # If the key is from an shelving
            if shelving and shelving is not None:
                # Check the shelving attributes
                if len(name) > 0:
                    shelving.name = name

                if picture != "":
                    shelving.picture = images.resize(picture, 300, 250)

                aux2 = shelving.put()
                time.sleep(1)

                # If the modification was successful
                if aux2 is not None:
                    # Variables to be sent to the HTML page
                    values["ok_message"] = lang["shelving_modified_successfully"]    # Ok message (Shelving modified successfully)

                    # Get all db Comics (Limited to the number given by the session variable [10 by default])
                    if len(aux3) > 0:
                        comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(self.session.get('num_elems_page'), offset=offset)
                        # Get the comics (if --> default, else --> see shelving)
                        if not self.session.get('shelving'):
                            comics = self.get_comics_read_and_without_shelving(
                                comics)  # Get read comics and the ones that aren't in a shelving
                        else:
                            self.get_comics_read(comics)  # Get read comics
                        values["comics"] = comics
                    else:
                        comics = ComicBook.query().fetch()

                    # Get the user shelvings
                    shelvings = Shelving.query(Shelving.username == self.session.get("session_name")).order(Shelving.name).fetch()
                    values["shelvings"] = shelvings

                # Else show an error message
                else:
                    # Variables to be sent to the HTML page
                    values["error_message"] = lang["error_modify"]  # Error message (The modification couldn't be done)

                del aux2    # Delete variables to free memory

            # Else show an error message
            else:
                # Values to be sent to the HTML page
                values["error_message"] = lang["shelving_not_modified"]   # Error message (Shelving couldn't be modified)

            all_comics = ComicBook.query().fetch()  # ALL comics (for the search field)
            values["all_comics"] = all_comics

            del lang, name, key, shelving, keys_page_list, aux_all_keys, aux, aux3, \
                all_comics, offset, all_keys, all_comics_user, shelvings     # Delete variables to free memory
            self.session_store.save_sessions(self.response)  # Save sessions
            self.response.write(jinja.render_template("/library/default.html", **values))  # Go to the library home page

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#19
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in
        if self.session.get('session_role') == 'client':
            # If it's logged in, get the session variables, show the home page
            # Get the search field
            search = self.request.get("search", "")  # Sort option
            search = search.encode("utf8")

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            # Initializing variables
            all_keys = list()
            comics = list()
            pages = list()
            keys_page_list = list()
            all_comics = ComicBook.query().fetch()

            all_comics_user = ComicBook.query(
                ComicBook.users.username == self.session.get(
                    'session_name')).fetch()

            # Get the shelvings
            shelvings = Shelving.query(
                Shelving.username == self.session.get('session_name')).order(
                    Shelving.name).fetch()

            # Variables to be sent to the HTML page
            values = {
                "lang":
                lang,  # Language strings
                "session_name":
                self.session.get('session_name'),  # User name
                "session_role":
                self.session.get('session_role'),  # User role
                "session_picture":
                self.get_session_image(
                    self.session.get('session_name')),  # User picture
                "session_genre":
                self.session.get('session_genre'),  # User genre
                "comics":
                comics,  # Comics
                "current_number_page":
                self.session.get('current_number_page'),  # Current number page
                "pages":
                self.session.get('pages'),  # Pages for the pagination
                "last_page":
                self.session.get('last_page'),  # Last page number
                "keys_page_list":
                keys_page_list,  # Comics keys that are currently in the page
                "all_keys":
                all_keys,  # All comic keys
                "all_comics_user":
                all_comics_user,  # All user comic (for the search field)
                "all_comics":
                all_comics,  # ALL comics (for the user search field)
                "shelvings":
                shelvings  # All user shelvings
            }

            # Check if there is a field to search
            if search != "" and len(search) > 0:
                # Get the key sent in the search field
                key = ndb.Key(urlsafe=search)

                # Get the comics with that key
                comic = key.get()

                # Check if the comics exists
                if comic and comic is not None:
                    comics.append(comic)  # Comics list
                    comics = self.get_comics_read_and_without_shelving(
                        comics)  # Get only the comics without a shelving
                    values["comics"] = comics  # Search results

                    # Setting all the comic keys
                    all_keys.append(comic.key.urlsafe())
                    values["all_keys"] = all_keys
                    # Setting the keys list to allow the use of the "Delete page" button
                    keys_page_list.append(comic.key.urlsafe())
                    values["keys_page_list"] = keys_page_list

                # If not exists, shows a message
                else:
                    values["ok_message"] = lang[
                        "search_not_results"]  # Ok message (No matches found)

                del key, comic  # Delete variables to free memory

            # If not exists, shows a message
            else:
                values["ok_message"] = lang[
                    "search_not_results"]  # Ok message (No matches found)

            del search, comics, pages, keys_page_list, all_keys, lang, all_comics_user, all_comics  # Delete variables to free memory
            self.response.write(
                jinja.render_template("/library/default.html",
                                      **values))  # Go to the library home page

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#20
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in. If it's logged in, show the home page
        if self.session.get('session_role') == 'client':
            user = User.query(User.name == self.session.get(
                "session_name")).fetch()  # Current user
            # Get the friend id
            search = self.request.get("search", "")

            # If users exists, get friends and friends requests
            if user and len(user) > 0:
                user = user[0]
                all_comics = ComicBook.query()
                comics = copy.copy(all_comics)
                comics = comics.filter(ComicBook.users.username == self.
                                       session.get("session_name")).fetch()
                all_comics = all_comics.fetch()
                all_users = User.query(User.role == "client").fetch()

                # Set the default language of the app
                if self.session['session_idiom'] == "spa":
                    lang = spa  # Spanish strings
                elif self.session['session_idiom'] == "eng":
                    lang = eng  # English strings
                else:
                    lang = eng  # Default english

                # Variables to be sent to the HTML page
                values = {
                    "lang":
                    lang,  # Language strings
                    "session_name":
                    self.session.get('session_name'),  # User name
                    "session_role":
                    self.session.get('session_role'),  # User role
                    "session_picture":
                    self.get_session_image(
                        self.session.get('session_name')),  # User picture
                    "session_genre":
                    self.session.get('session_genre'),  # User genre
                    "all_comics":
                    all_comics,  # ALL comic (for the users search field)
                    "all_users":
                    all_users,  # ALL users (for the search field)
                    "comics":
                    comics,  # Current user comics (for the borrowinngs)
                }

                # If the key is valid
                if len(search) > 0:
                    search = ndb.Key(urlsafe=search)
                    search = search.get()

                    # If the user exists, see if it's a friend, request other user
                    if search and search is not None:
                        all = Friend.query(
                            Friend.who_ask == search.key,
                            Friend.who_answer == user.key).fetch()
                        aux = copy.copy(all)
                        all = Friend.query(
                            Friend.who_ask == user.key,
                            Friend.who_answer == search.key).fetch()
                        all += aux
                        is_friend = None
                        aux = None

                        # See if the user is already a friend or has a friend request
                        for elem in all:
                            if elem.who_ask == search.key and elem.who_answer == user.key:
                                is_friend = elem.is_friend
                                aux = True
                                break
                            else:
                                aux = False
                            del elem

                        # Variables to be shown in the HTML page
                        if is_friend is None and aux is None:
                            others = list()
                            others.append(search)
                            values["others"] = others
                            del others
                        else:
                            if is_friend == False and aux == True:
                                requests = list()
                                requests.append(search)
                                values["requests"] = requests
                                del requests
                            elif is_friend == True and aux == True:
                                friends = list()
                                friends.append(search)
                                values["friends"] = friends
                                del friends

                        del all, is_friend, aux  # Delete variables to free memory

                    # Else show a message
                    else:
                        values["ok_message"] = lang[
                            "search_not_results"]  # There aren't any search result

                # Else show a message
                else:
                    values["ok_message"] = lang[
                        "search_not_results"]  # There aren't any search result

                del lang, user, all_comics, all_users, search
                self.session_store.save_sessions(
                    self.response)  # Save sessions
                self.response.write(
                    jinja.render_template(
                        "/friends/default.html",
                        **values))  # Go to the friends home page

            # Else redirect to the login page
            else:
                del user  # Delete variables to free memory
                self.redirect("/login")

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#21
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the admin is logged in. If it's logged in, show the home page
        if self.session.get('session_role') == 'admin':
            pages_to_show = self.session.get(
                'pages_to_show')  # Number of pages that shows the pagination
            pages = list(
            )  # Pages for the pagination (it's a list because of django for templates)

            # Retrieve the page number
            page_number = self.request.get(
                "page", self.session.get('current_number_page'))
            page_number = int(page_number)

            # If the page number sent by HTML is above 0
            if page_number > 0:
                # Initialize variables
                all_keys = list()  # New comic keys list
                comics = list()  # Comics list
                aux3 = list()  # All comic keys support list
                all_comics = list()  # ALL comics (for the search field)

                # Set the offset for the query (offset allows to ignore an amount of query results given by its value)
                num_elems_page = self.session.get('num_elems_page')
                offset = num_elems_page * (page_number - 1)

                # Get ALL keys from ALL comics (I do this because I want to maintain the ordinations and filters done in the list)
                aux_all_keys = self.request.get("all_keys",
                                                "")  # All comic keys list

                # Check if the comics keys are empty
                if len(aux_all_keys) > 2:
                    # Transform the HTML string in a list
                    aux_all_keys = self.transform_keys(aux_all_keys)

                    # It's necessary to compare the HTML with the query list in order to obtain the desired list, like I said
                    comics = ComicBook.query()
                    all_comics = copy.copy(
                        comics)  # ALL comics (for the search field)
                    all_comics = all_comics.fetch()

                    aux = list()
                    for comic in comics:  # Get ALL the keys
                        aux.append(comic.key.urlsafe())
                        del comic

                    for key in aux_all_keys:  # Compare the "list" given by HTML with aux for making the new all keys list (all_keys)
                        for key2 in aux:
                            if key == str(key2):
                                key2 = ndb.Key(urlsafe=key)
                                all_keys.append(key2)
                                aux3.append(key2.urlsafe())
                                break
                            del key2
                        del key

                    del aux  # Delete variables to free memory

                    # Get all db comics (Limited to the number given by the session variable [10 by default])
                    # Not ordered because it has to respect if the comic used some ordination or filter
                    comics = ComicBook.query(ComicBook.key.IN(all_keys)).fetch(
                        num_elems_page, offset=offset)

                num_total = len(aux_all_keys)  # Total number of elements

                # Setting all the comic keys
                all_keys = aux3
                del aux3  # Delete variables to free memory

                # If the total number of elements is above 0 do the pagination
                if num_total > 0:
                    # Get the number of pages for the pagination
                    num_pages = num_total / num_elems_page  # Number of pages

                    # If the page number sent by html is less than the last possible page
                    if page_number <= (num_pages + 1):
                        # Update the session current number page
                        self.session['current_number_page'] = page_number
                        current_number_page = page_number

                        # If there are less elements than session["num_elems_page"]
                        if num_pages == 0:
                            num_pages = 1  # At least one page
                        # Else
                        else:
                            # If the rest of the division is above 0
                            if (num_total % num_elems_page) > 0:
                                num_pages = (num_total / num_elems_page
                                             ) + 1  # It's necessary other page
                            else:
                                num_pages = (num_total / num_elems_page
                                             )  # It doesn't need other page

                        self.session['last_page'] = num_pages  # Last page

                        # Set the pages for the pagination
                        for i in range(1, num_pages + 1):
                            pages.append(i)

                        # If the current page is 1
                        if current_number_page == 1:
                            pages = pages[0:pages_to_show]  # Shows pages 1,2,3
                        # If the current page is the final page
                        elif current_number_page == num_pages:  # Shows the last three pages
                            if (num_pages - pages_to_show) >= 0:
                                pages = pages[(num_pages - pages_to_show):]
                            else:
                                pages = pages[0:pages_to_show]
                        # Else
                        else:
                            pages = pages[(current_number_page - 2):(
                                current_number_page +
                                1)]  # Show the current, last and next pages

                        self.session[
                            'pages'] = pages  # Pages for the pagination

                        # Set the default language of the app
                        if self.session['session_idiom'] == "spa":
                            lang = spa  # Spanish strings
                        elif self.session['session_idiom'] == "eng":
                            lang = eng  # English strings
                        else:
                            lang = eng  # Default english

                        # Setting the keys list to allow the use of the "Delete page" button
                        keys_page_list = list()
                        for comic in comics:
                            keys_page_list.append(comic.key.urlsafe())
                            del comic

                        # Variables to be sent to the HTML page
                        values = {
                            "lang":
                            lang,  # Language strings
                            "session_name":
                            self.session.get('session_name'),  # User name
                            "session_role":
                            self.session.get('session_role'),  # User role
                            "session_picture":
                            self.get_session_image(
                                self.session.get(
                                    'session_name')),  # User picture
                            "session_genre":
                            self.session.get('session_genre'),  # User genre
                            "comics":
                            comics,  # Comics
                            "current_number_page":
                            self.session.get(
                                'current_number_page'),  # Current number page
                            "pages":
                            self.session.get(
                                'pages'),  # Pages for the pagination
                            "last_page":
                            self.session.get('last_page'),  # Last page number
                            "keys_page_list":
                            keys_page_list,  # Comics keys that are currently in the page
                            "all_keys":
                            all_keys,  # All comic keys
                            "all_comics":
                            all_comics,  # ALL comic (for the search field)
                            "authors":
                            self.get_authors(
                            )  # Authors for adding them to the comics
                        }

                        del pages_to_show, page_number, num_elems_page, num_total, offset, \
                            num_pages, current_number_page, pages, keys_page_list, comics, aux_all_keys, all_keys,\
                            all_comics  # Delete variables to free memory

                        self.session_store.save_sessions(
                            self.response)  # Save sessions
                        self.response.write(
                            jinja.render_template(
                                "/comics/default.html",
                                **values))  # Go to the comics home page

                    # If it isn't less redirect to comics home page
                    else:
                        del pages_to_show, page_number, pages, num_elems_page, num_total, offset, comics, num_pages, \
                            aux_all_keys, all_comics   # Delete variables to free memory
                        self.redirect("/comics")

                # If the total number is not above 0, redirect to the comics home page
                else:
                    del pages_to_show, page_number, pages, offset, comics, num_elems_page, aux_all_keys  # Delete variables to free memory
                    self.redirect("/comics")

            # If it isn't above redirect to comics home page
            else:
                del pages_to_show, page_number, pages  # Delete variables to free memory
                self.redirect("/comics")

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#22
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the admin or client are logged in
        if self.session.get('session_role') == 'admin' or self.session.get(
                'session_role') == 'client':
            # If it's logged in, get the session variables
            # Get the user attributes
            key = self.request.get("key", "")  # User key
            key = ndb.Key(urlsafe=key)

            user = key.get()  # Get the user with that key

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            # Variables to be sent to the HTML page
            values = {
                "lang":
                lang,  # Language strings
                "session_name":
                self.session.get('session_name'),  # User name
                "session_role":
                self.session.get('session_role'),  # User role
                "session_picture":
                self.get_session_image(
                    self.session.get('session_name')),  # User picture
                "user_email":
                user.email,  # User email
                "user_key":
                user.key.urlsafe(),  # User key
                "user_genre":
                self.session.get('session_genre'),  # User genre
                "statistics":
                self.get_statistics()  # Client statistics
            }

            # If the user and key exist
            if user is not None and key is not None:
                # Delete all associations between ComicBook and User_ComicBook
                aux = list()
                comics = ComicBook.query(ComicBook.users.username == user.name)
                for comic in comics:
                    for user_comic in comic.users:
                        if user_comic.username != user.name:
                            aux.append(user_comic)
                    comic.users = aux
                    comic.put()
                    del comic
                    aux = list()
                del aux

                # Delete the client library
                shelvings = Shelving.query(Shelving.username == user.name)
                for shelving in shelvings:
                    shelving.key.delete()
                    del shelving

                # Delete all user User_ComicBook rows
                user_comics = User_ComicBook.query(
                    User_ComicBook.username == user.name)
                for user_comic in user_comics:
                    user_comic.key.delete()
                    del user_comic

                # Delete all user friends
                friends = Friend.query(
                    ndb.OR(Friend.who_ask == user.key,
                           Friend.who_answer == user.key))
                for friend in friends:
                    friend.key.delete()

                # Delete the user
                user.key.delete()
                del lang, key, user, user_comics, comics, shelvings, friends  # Delete variables to free memory

                self.redirect("/logout")  # Redirect to the login page

            # Else show an error message
            else:
                # Values to be sent to the HTML page
                values["error_message"] = lang[
                    "account_not_deleted"]  # Error message (Account couldn't be modified)
                del lang, key, user  # Delete variables to free memory

                self.session_store.save_sessions(
                    self.response)  # Save sessions
                self.response.write(
                    jinja.render_template(
                        "/profile/default.html",
                        **values))  # Go to the profile home page

        # If they aren't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#23
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in
        if self.session.get('session_role') == 'client':
            # If it's logged in, get the session variables, show the home page
            # Get the search field
            search = self.request.get("search", "")  # Comic
            search = search.encode("utf8")

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            self.session['page_name'] = "/user_search"  # Current page name

            # Initializing variables
            comics = list()

            all_comics = ComicBook.query()

            # Variables to be sent to the HTML page
            values = {
                "lang":
                lang,  # Language strings
                "session_name":
                self.session.get('session_name'),  # User name
                "session_role":
                self.session.get('session_role'),  # User role
                "session_picture":
                self.get_session_image(
                    self.session.get('session_name')),  # User picture
                "session_genre":
                self.session.get('session_genre'),  # User genre
                "comics":
                comics,  # Comics
                "all_comics":
                all_comics  # All comics (for the user search)
            }

            # Check if there is a field to search
            if search != "" and len(search) > 0:
                # Get the key sent in the search field
                key = ndb.Key(urlsafe=search)

                # Get the comics with that key
                comic = key.get()

                # Check if the comics exists
                if comic and comic is not None:
                    comics.append(comic)  # Comics list
                    self.get_own_comics(
                        comics)  # Get the comics added by the user
                    values["comics"] = comics  # Search results

                # If not exists, shows a message
                else:
                    values["ok_message"] = lang[
                        "search_not_results"]  # Ok message (No matches found)

                del key, comic  # Delete variables to free memory

            # If not exists, shows a message
            else:
                values["ok_message"] = lang[
                    "search_not_results"]  # Ok message (No matches found)

            del search, comics, lang  # Delete variables to free memory
            self.response.write(
                jinja.render_template("/elements/user_search_results.html",
                                      **values))  # Go to the comics home page

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#24
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in
        if self.session.get('session_role') == 'client':
            # If it's logged in, get the session variables, show the home page
            # Get the comic attributes
            state = self.request.get("state", "")       # Comic read or unread
            state = state.decode("utf8")

            key = self.request.get("comic_key", "")
            key = ndb.Key(urlsafe=key)
            comic = key.get()      # Get the comic with that key

            keys_page_list = self.request.get("keys_page_list", "")     # Comic keys (only comics in the current page)
            aux_all_keys = self.request.get("all_keys", "")             # All the comic keys (for the order field)

            # Initialize variables
            aux = list()                    # Support variable
            aux3 = list()                   # Support variable
            all_comics_user = list()        # List with all comics (for the search field)
            all_comics = list()             # All comics (for the user search field)

            # Transform the HTML string in a list
            all_keys = copy.copy(aux_all_keys)
            aux_all_keys = self.transform_keys(aux_all_keys)

            comics = ComicBook.query()
            for comic2 in comics:  # Get ALL the keys
                aux.append(comic2.key.urlsafe())
                del comic2

            for key3 in aux_all_keys:  # Compare the "list" given by HTML with aux for making the new all keys list (all_keys)
                for key2 in aux:
                    if key3 == str(key2):
                        key2 = ndb.Key(urlsafe=key2)
                        aux3.append(key2)
                        break
                    del key2
                del key3

            # Get all db comics
            offset = (self.session.get('current_number_page') - 1) * self.session.get('num_elems_page')
            comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(self.session.get('num_elems_page'), offset=offset)

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            # Variables to be sent to the HTML page
            values = {
                "lang": lang,                                                                   # Language strings
                "session_name": self.session.get('session_name'),                               # User name
                "session_role": self.session.get('session_role'),                               # User role
                "session_picture": self.get_session_image(self.session.get('session_name')),    # User picture
                "session_genre": self.session.get('session_genre'),                             # User genre
                "comics": comics,                                                               # Comics
                "current_number_page": self.session.get('current_number_page'),                 # Current number page
                "pages": self.session.get('pages'),                                             # Pages for the pagination
                "last_page": self.session.get('last_page'),                                     # Last page number
                "keys_page_list": keys_page_list,                                               # Comics keys that are currently in the page
                "all_keys": all_keys,                                                           # All comic keys
                "all_comics_user": all_comics_user,                                             # All user comic (for the search field)
                "all_comics": all_comics                                                        # ALL comics (for the user search field)
            }

            # If the key is from an comic
            if comic and comic is not None and (state == "read" or state == "unread"):
                # Modify the comic state
                for user_comic in comic.users:
                    if user_comic.username == self.session.get("session_name"):
                        user_comic.state = state

                aux2 = comic.put()
                time.sleep(1)

                # If the modification was successful
                if aux2 is not None:
                    # Variables to be sent to the HTML page
                    values["ok_message"] = lang["comic_modified_successfully"]    # Ok message (Comic modified successfully)

                    # Get all db Comics (Limited to the number given by the session variable [10 by default])
                    comics = ComicBook.query(ComicBook.key.IN(aux3)).fetch(self.session.get('num_elems_page'), offset=offset)
                    values["comics"] = comics

                # Else show an error message
                else:
                    # Variables to be sent to the HTML page
                    values["error_message"] = lang["error_modify"]  # Error message (The modification couldn't be done)

                del aux2    # Delete variables to free memory

            # Else show an error message
            else:
                # Values to be sent to the HTML page
                values["error_message"] = lang["comic_not_modified"]   # Error message (Comic couldn't be modified)

            all_comics_user = ComicBook.query(ComicBook.users.username == self.session.get('session_name')).fetch()
            values["all_comics_user"] = all_comics_user
            all_comics = ComicBook.query().fetch()
            self.get_read_comics(comics)

            del lang, key, comic, keys_page_list, aux_all_keys, aux, aux3, \
                all_comics_user, offset, all_keys, all_comics     # Delete variables to free memory
            self.session_store.save_sessions(self.response)  # Save sessions
            self.response.write(jinja.render_template("/collection/default.html", **values))  # Go to the collection home page

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#25
0
    def get(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in. If it's logged in, show the home page
        if self.session.get('session_role') == 'client':
            user = User.query(User.name == self.session.get(
                "session_name")).fetch()  # Current user

            # If users exists, get borrowings
            if user and len(user) > 0:
                self.session['page_name'] = "/borrowings"  # Current page name

                user = user[0]
                # Get db borrowings
                all = Borrowing.query()

                # Db borrowed comics
                borrow_comics = copy.copy(all)
                borrow_comics = borrow_comics.filter(
                    Borrowing.is_borrowed == True)
                borrow_comics = borrow_comics.filter(
                    Borrowing.who_borrow == user.key)
                aux = list()
                for borrow_comic in borrow_comics:
                    aux2 = borrow_comic.comic.get()
                    aux3 = borrow_comic.who_want.get()
                    aux2.owner_name = aux3.name
                    aux.append(aux2)
                    del borrow_comic, aux2, aux3
                borrow_comics = aux

                # Db asked comics
                orders = copy.copy(all)
                orders = orders.filter(Borrowing.is_borrowed == False)
                orders = orders.filter(Borrowing.who_borrow == user.key)
                aux = list()
                for order in orders:
                    aux2 = order.comic.get()
                    aux3 = order.who_want.get()
                    aux2.owner_name = aux3.name
                    aux.append(aux2)
                    del order, aux2, aux3
                orders = aux

                # Db comics that user ask for
                own = copy.copy(all)
                own = own.filter(Borrowing.is_borrowed == True)
                own = own.filter(Borrowing.who_want == user.key)
                aux = list()
                for elem in own:
                    aux2 = elem.comic.get()
                    aux3 = elem.who_borrow.get()
                    aux2.owner_name = aux3.name
                    aux.append(aux2)
                    del elem, aux2, aux3
                own = aux

                # Set the default language of the app
                if self.session['session_idiom'] == "spa":
                    lang = spa  # Spanish strings
                elif self.session['session_idiom'] == "eng":
                    lang = eng  # English strings
                else:
                    lang = eng  # Default english

                all_comics = ComicBook.query().fetch()

                # Variables to be sent to the HTML page
                values = {
                    "lang":
                    lang,  # Language strings
                    "session_name":
                    self.session.get('session_name'),  # User name
                    "session_role":
                    self.session.get('session_role'),  # User role
                    "session_picture":
                    self.get_session_image(
                        self.session.get('session_name')),  # User picture
                    "session_genre":
                    self.session.get('session_genre'),  # User genre
                    "borrow_comics":
                    borrow_comics,  # Borrowed comics
                    "orders":
                    orders,  # Asked comics
                    "own":
                    own,  # Comics that current user ask for
                    "all_comics":
                    all_comics,  # ALL comic (for the users search field)
                }

                del lang, user, all, borrow_comics, orders, aux, all_comics, own
                self.session_store.save_sessions(
                    self.response)  # Save sessions
                self.response.write(
                    jinja.render_template(
                        "/borrowings/default.html",
                        **values))  # Go to the borrowings home page

            # Else redirect to the login page
            else:
                del user  # Delete variables to free memory
                self.redirect("/login")

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")
示例#26
0
    def post(self):
        jinja = jinja2.get_jinja2(app=self.app)

        # Check if the client is logged in
        if self.session.get('session_role') == 'client':
            # Initialize variables
            all_keys = list()  # New comic keys list
            comics = None  # Comics list
            all_comics_user = list()  # ALL comics (for the search field)
            pages = list()  # Pages for the pagination

            # If it's logged in, get the session variables, show the home page
            # Get the filter attributes
            filter_by = self.request.get_all("filter_by[]")  # Filter option
            aux_all_keys = self.request.get("all_keys",
                                            "")  # All comic keys list

            # Set the default language of the app
            if self.session['session_idiom'] == "spa":
                lang = spa  # Spanish strings
            elif self.session['session_idiom'] == "eng":
                lang = eng  # English strings
            else:
                lang = eng  # Default english

            if len(aux_all_keys) > 2:
                # Transform the HTML string in a list
                aux_all_keys = self.transform_keys(aux_all_keys)

                # It's necessary to compare the HTML with the query list in order to obtain the desired list, like I said
                comics = ComicBook.query(ComicBook.users.username ==
                                         self.session.get('session_name'))
                all_comics_user = copy.copy(
                    comics)  # ALL comics (for the search field)
                all_comics_user = all_comics_user.fetch()

                aux = list()
                for comic in comics:  # Get ALL the keys
                    aux.append(comic.key.urlsafe())
                    del comic

                for key in aux_all_keys:  # Compare the "list" given by HTML with aux for making the new all keys list (all_keys)
                    for key2 in aux:
                        if key == str(key2):
                            key2 = ndb.Key(urlsafe=key)
                            all_keys.append(key2)
                            break
                        del key2
                    del key

                del aux  # Delete variables to free memory

                # Get all db comics (Limited to the number given by the session variable [10 by default])
                # Not ordered because it has to respect if the comic used some ordination or filter
                comics = ComicBook.query(ComicBook.key.IN(all_keys))

            # If there is a list of comics and a sort option
            if len(filter_by) > 0 and comics is not None:
                ok_message = lang[
                    "filtered_by"] + ": "  # Ok message (filters applied)

                for i in range(0, len(filter_by)):
                    # Filter the comic list
                    if filter_by[i] == "comic" or filter_by[
                            i] == "manga" or filter_by[i] == "anthology":
                        comics = ComicBook.query(
                            ComicBook.key.IN(all_keys)).filter(
                                ComicBook.type ==
                                filter_by[i])  # Type male or female
                    elif filter_by[i] == "american" or filter_by[
                            i] == "european" or filter_by[i] == "other":
                        comics = ComicBook.query(
                            ComicBook.key.IN(all_keys)).filter(
                                ComicBook.origin ==
                                filter_by[i])  # Origin admin or client
                    elif filter_by[i] == "read" or filter_by[i] == "unread":
                        comics = ComicBook.query(
                            ComicBook.key.IN(all_keys)).filter(
                                ComicBook.users.username
                                == self.session.get("session_name")
                                and ComicBook.users.state
                                == filter_by[i])  # Comic read or unread

                    # Setting the all comic keys list
                    all_keys = list()
                    aux_all_keys = list()
                    if comics.count() > 0:
                        for comic in comics:
                            aux_all_keys.append(comic.key.urlsafe())
                            all_keys.append(comic.key)
                            del comic

                        comics = comics.fetch(
                            self.session.get('num_elems_page')
                        )  # Setting the first page to show
                    else:
                        comics = list()

                    ok_message += lang[filter_by[i]].lower(
                    ) + ", "  # Update the ok message (the filter applied)

                ok_message = ok_message[:len(
                    ok_message
                ) - 2]  # Update the ok message (remove the last ", ")
                all_keys = aux_all_keys

                # Get the number of pages for the pagination
                num_total = len(all_keys)
                num_elems_page = self.session.get(
                    'num_elems_page')  # Number of elements (comics) per page
                num_pages = num_total / num_elems_page  # Number of pages

                if num_pages > 0:
                    # If the rest of the division is above 0
                    if (num_total % num_elems_page) > 0:
                        num_pages = (num_total / num_elems_page
                                     ) + 1  # It's necessary other page
                    else:
                        num_pages = (num_total / num_elems_page
                                     )  # It doesn't need other page

                    # Set the pages for the pagination
                    if num_pages >= self.session.get('pages_to_show'):
                        for i in range(1,
                                       self.session.get('pages_to_show') + 1):
                            pages.append(i)
                    else:
                        for i in range(1, num_pages + 1):
                            pages.append(i)

                # Setting the comic keys list (only on the current page)
                keys_page_list = list()
                for comic in comics:
                    keys_page_list.append(comic.key.urlsafe())
                    del comic

                all_comics = ComicBook.query().fetch()
                self.get_read_comics(comics)

                # Variables to be sent to the HTML page
                values = {
                    "lang":
                    lang,  # Language strings
                    "session_name":
                    self.session.get('session_name'),  # User name
                    "session_role":
                    self.session.get('session_role'),  # User role
                    "session_picture":
                    self.get_session_image(
                        self.session.get('session_name')),  # User picture
                    "session_genre":
                    self.session.get('session_genre'),  # User genre
                    "comics":
                    comics,  # Comics
                    "current_number_page":
                    self.session.get(
                        'current_number_page'),  # Current number page
                    "pages":
                    self.session.get('pages'),  # Pages for the pagination
                    "last_page":
                    self.session.get('last_page'),  # Last page number
                    "keys_page_list":
                    keys_page_list,  # Comics keys that are currently in the page
                    "all_keys":
                    all_keys,  # All comic keys
                    "all_comics_user":
                    all_comics_user,  # All user comic (for the search field)
                    "all_comics":
                    all_comics,  # ALL comics (for the user search field)
                    "filter_message":
                    ok_message  # Applied filters message
                }

                del filter_by, aux_all_keys, all_keys, comics, lang, keys_page_list, pages,\
                    num_total, num_pages, num_elems_page, all_comics_user, ok_message    # Delete variables to free memory

                self.session_store.save_sessions(
                    self.response)  # Save sessions
                self.response.write(
                    jinja.render_template(
                        "/collection/default.html",
                        **values))  # Go to the comics home page

            # Else redirect to the comics home page
            else:
                del filter_by, aux_all_keys, all_keys, comics  # Delete variables to free memory
                self.redirect("/collection")

        # If it isn't logged in, redirect to the login page
        else:
            self.redirect("/login")