def post(self): """ Create new user """ response_obj = Response(mimetype='application/json') data = get_request_data(request) user_data = data.get('user', None) if not user_data: return {'message': 'No input data provided'}, 400 # Validate and deserialize input data, errors = user_schema.load(user_data) print(errors, "....................") if errors: return {"status": "error", "data": errors}, 422 user = User(username=data['username'], password=data['password'], role=data['role']) db.session.add(user) db.session.commit() result_obj = user_schema.dump(user).data response_obj.data = json.dumps(result_obj) return response_obj
def get(self): jinja = jinja2.get_jinja2(app=self.app) # Check if the admin and client are logged in if self.session.get('session_role') == 'admin' or self.session.get( 'session_role') == 'client': # Get the user user = User.query(User.name == self.session.get( 'session_name')).fetch() # Username is unique (teorically) # Check the user data if user and len(user) == 1: # 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'] = "/profile" # Current page name # 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": user[0].picture, # User picture "user_email": user[0].email, # User email "user_key": user[0].key.urlsafe(), # User key "user_genre": self.session.get('session_genre'), # User genre "statistics": self.get_statistics() # Client statistics } del lang # 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 the user doesn't exist or there more than 1 user with the same name, redirect to the login page else: self.redirect("/login") # If they aren't logged in, redirect to the login page else: self.redirect("/login")
def post(self): username = self.get_argument("username") user = User.getUser(username) if user: password = self.get_argument("password") if user.password == password: self.set_secure_cookie("name", username) self.finish("0") #匹配成功 #self.redirect("/") #return else: self.finish("-1") #密码错误 else: self.finish("1") #用户名错误
def post(self): username = self.get_argument("username") user = User.getUser(username) if user: password = self.get_argument("password") if user.password == password: self.set_secure_cookie("name",username) self.finish("0") #匹配成功 #self.redirect("/") #return else: self.finish("-1") #密码错误 else: self.finish("1") #用户名错误
def post(self): # Retrieve the language language = self.request.get("lang", "") language = language.encode("utf8") # If the user selects a language, do the change if len(language) > 0: # Change the session variable language if language == "spa": self.session['session_idiom'] = "spa" # Spanish elif language == "eng": self.session['session_idiom'] = "eng" # English else: self.session['session_idiom'] = "eng" # Default english # Set the new language in the database if len(self.session['session_name']) > 0: user = User.query(User.name == self.session['session_name']) user = user.get() user.language = language user.put() time.sleep(1) del user del language # Delete variables to free memory self.session_store.save_sessions(self.response) # Save sessions # If there is an user in the app return to the home page, else return to the login page if len(self.session['session_name']) > 0: self.redirect( self.session.get('page_name') ) # Redirect to the last main page the user visited else: self.redirect("/login") # Redirect to the login page # Else return to the home page else: del language # Delete variables to free memory self.redirect("/home")
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")
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 user attributes email = self.request.get("m_email", "") # User email email = email.encode("utf8") password1 = self.request.get("m_password", "") # User password password1 = password1.encode("utf8") password2 = self.request.get("m_r_password", "") # User password password2 = password2.encode("utf8") name = self.request.get("m_username", "") # User name name = name.encode("utf8") genre = self.request.get("m_genre", "") # User genre genre = genre.encode("utf8") role = self.request.get("m_role", "") # User role role = role.encode("utf8") picture = self.request.get("m_picture", "") # User picture key = self.request.get("key", "") key = ndb.Key(urlsafe=key) user = key.get() # Get the user with that key keys_page_list = self.request.get( "keys_page_list", "") # User keys (only users in the current page) aux_all_keys = self.request.get( "all_keys", "") # All the user keys (for the order field) # Initialize variables aux = list() # Support variable aux3 = list() # Support variable all_users = list() # List with all users (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) users = User.query() for user2 in users: # Get ALL the keys aux.append(user2.key.urlsafe()) del user2 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 users offset = (self.session.get('current_number_page') - 1) * self.session.get('num_elems_page') users = User.query(User.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 "users": users, # Users "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, # Users keys that are currently in the page "all_keys": all_keys, # All user keys "all_users": all_users # ALL user (for the search field) } # If the key is from an user if user and user is not None: # If there is a genre to modify if genre == "male" or genre == "female": user.genre = genre # If there is a role to modify if role == "admin" or role == "client": user.role = role # If there is a picture to modify if picture != "": user.picture = images.resize(picture, 250, 250) # If there is a name or email to modify if len(name) > 0 or len(email) > 0: aux_user = User.query( ndb.OR(User.email == email, User.name == name)).fetch() # Check if the user name already exists if len(aux_user) > 0: values["error_message"] = lang["user_already_exists"] else: if len(email) > 0: user.email = email if len(name) > 0: user.name = name del aux_user # Delete variables to free memory # If there is a password to modify if len(password1) > 0 and len(password2) > 0: if self.check_passwords(password1, password2): user.password = password1 # Set the user aux2 = user.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[ "user_modified_successfully"] # Ok message (User modified successfully) # Get all db users (Limited to the number given by the session variable [10 by default]) users = User.query(User.key.IN(aux3)).fetch( self.session.get('num_elems_page'), offset=offset) values["users"] = users # 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[ "user_not_modified"] # Error message (User couldn't be modified) all_users = User.query().fetch( ) # ALL users (for the search field) values["all_users"] = all_users del lang, name, key, user, keys_page_list, aux_all_keys, aux, aux3, users, \ all_users, offset, all_keys, email, role, picture, genre, password1, password2 # Delete variables to free memory self.session_store.save_sessions(self.response) # Save sessions self.response.write( jinja.render_template("/users/default.html", **values)) # Go to the users home page # If it isn't logged in, redirect to the login page else: self.redirect("/login")
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")
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")
def post(self): jinja = jinja2.get_jinja2(app=self.app) # If an admin is logged in delete the user if self.session.get('session_role') == 'admin': # Retrieving the user key key = self.request.get("key", "") key = ndb.Key(urlsafe=key) user = key.get() # Get the db user with that key keys_page_list = self.request.get("keys_page_list", "") # User keys (only users in the current page) aux_all_keys = self.request.get("all_keys", "") # All the user keys (for the order field) # Initialize variables all_keys = list() # All the user 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) users = User.query() all_users = copy.copy(users) # ALL users (for the search field) all_users = all_users.fetch() for user2 in users: # Get ALL the keys aux.append(user2.key.urlsafe()) del user2 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 users offset = (self.session.get('current_number_page') - 1) * self.session.get('num_elems_page') users = User.query(User.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 "users": users, # Users "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, # Users keys that are currently in the page "all_keys": all_keys, # All user keys "all_users": all_users # ALL user (for the search field) } # If the user exists if user and user is not None: # Deleting the old user key to the user keys lists all_keys.remove(user.key.urlsafe()) aux3.remove(user.key) user.key.delete() # Delete db user values["ok_message"] = lang["user_deleted_successfully"] # Ok message (user 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 users (Limited to the number given by the session variable [10 by default]) num_total = len(aux3) # Total number of elements if len(aux3) > 0: users = User.query(User.key.IN(aux3)).fetch(self.session.get('num_elems_page'), offset=offset) # List not empty else: users = list() # If the total number of elements is above 0 do the pagination if num_total > 0 and len(users) > 0: # Get the number of pages for the pagination num_elems_page = self.session.get('num_elems_page') # Number of elements (users) 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(users) == 0: # Get all db users (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') users = User.query(User.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 (users) 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["users"] = users # Users 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 user keys values["current_number_page"] = self.session.get('current_number_page') # Current number page # Setting the all users list all_users = User.query().fetch() values["all_users"] = all_users # Setting the user keys list that are currently in the page keys_page_list = list() for user in users: keys_page_list.append(user.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["user_not_deleted"] # Error message (User couldn't be deleted) del key, user, keys_page_list, aux_all_keys, all_keys, aux, aux3, all_users, offset, users,\ lang # Delete variables to free memory self.session_store.save_sessions(self.response) # Save sessions self.response.write(jinja.render_template("/users/default.html", **values)) # Go to the users home page # Else redirect to the login page else: self.redirect("/login")
def post(self): jinja = jinja2.get_jinja2(app=self.app) # Retrieve the email written in the form email = self.request.get("email", "") email = email.encode("utf8") # Default values to be sent to the HTML page values = { "lang": lang, # Strings } # Check if the client sent an email, if not shows an error message (HTML and JS shouldn't allow this) if len(email) == 0: # Values to be sent to the HTML page values["error_message"] = lang[ "must_email"] # Error message (An email is required) del email # Delete variables to free memory self.response.write(jinja.render_template( "index.html", **values)) # Go to the login page # If client sent an email else: # Check if the user exists user = User.query(User.email == email) # It the user exists if user and user.count() > 0: user = list(user.fetch()) user = user[0] # Creating and encrypting a random password password = randomPassword() # Create the email to recuperate the password message = mail.EmailMessage( sender= "*****@*****.**", # Email sender, it has to be a Google account subject=lang["subject"]) # Email subject message.to = email # Email receiver message.body = lang["greeting"] + user.name + lang[ "body"] + password + lang["end"] # Email body # Set the user new password in the db user.password = encryptPassword(password) user.put() time.sleep(1) # Send the email message.send() del user, email, message, password # Delete variables to free memory self.redirect("/login") # Redirect to the login page # If the user doesn't exist, show an error message else: # Values to be sent to the HTML page values["error_message"] = lang[ "email_not_exist"] # Error message (Email doesn't exist) del user, email # Delete variables to free memory self.response.write( jinja.render_template("index.html", **values)) # Go to the login page
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")
def get_session_image(self, name): user = User.query(User.name == name).fetch() return user[0].picture
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 user attributes email = self.request.get("email", "") # User email email = email.encode("utf8") password1 = self.request.get("password", "") # User password password1 = password1.encode("utf8") password2 = self.request.get("r_password", "") # User password password2 = password2.encode("utf8") name = self.request.get("username", "") # User name name = name.encode("utf8") genre = self.request.get("genre", "") # User genre genre = genre.encode("utf8") role = self.request.get("role", "") # User role role = role.encode("utf8") picture = self.request.get("picture", "") # User picture keys_page_list = self.request.get( "keys_page_list", "") # User keys (only Users in the current page) aux_all_keys = self.request.get( "all_keys", "") # All the user keys (for the order field) # Initialize variables all_keys = list() # All the user keys (for the order field) all_users = list() # All users (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) users = User.query() all_users = copy.copy( users) # ALL users (for the search field) all_users = all_users.fetch() for user in users: # Get ALL the keys aux.append(user.key.urlsafe()) del user 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 users users = User.query(User.key.IN(aux3)).fetch( self.session.get('num_elems_page'), offset=offset) # If empty else: users = 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 "users": users, # Users "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, # User keys that are currently in the page "all_keys": all_keys, # All user keys "all_users": all_users # ALL user (for the search field) } # If the user enters all the attributes (the database can have more than one user with the same name) if len(email) > 0 and self.check_passwords( password1, password2) and len(role) > 0: user = User.query( ndb.OR(User.email == email, User.name == name)).fetch() # If an user already exists, show an error message if len(user) == 0: # Check the user attributes if len( name ) == 0: # Create an username if the user didn't write one pos = email.find("@") name = email[:pos] # Check if the new user name already exists aux_user = User.query(User.name == name).fetch() aux_name = name while len(aux_user) > 0: aux_name = name + str(random.randint(0, 999)) aux_user = User.query( User.name == aux_name).fetch() print(aux_name) name = aux_name # Setting the new user name del pos, aux_user, aux_name # Delete variables to free memory elif len(name) > 20: name = name[0:20] if role != "admin" and role != "client": role = "client" if len(genre ) == 0 and genre != "male" and genre != "female": genre = "not_defined" if picture != "": picture = images.resize(picture, 250, 250) else: picture = None # Add the new user to the home page user = User(email=email, password=encryptPassword(password1), name=name, genre=genre, role=role, picture=picture) aux2 = user.put() time.sleep(1) # If the user was successfully added if aux2 is not None: # Adding the new user and its key to the lists aux3.append(user.key) all_keys.append(user.key.urlsafe()) all_users.append(user) # 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 users (Limited to the number given by the session variable [10 by default]) users = User.query(User.key.IN(aux3)).fetch( self.session.get('num_elems_page'), offset=offset) # Setting the new keys list for the users currently in the page (allows to use the "Delete page" button) for user in users: keys_page_list.append(user.key.urlsafe()) del user num_total = len(all_users) # 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 (users) 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["users"] = users # Users 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[ "user_added_successfully"] # Ok message (user added successfully) values[ "keys_page_list"] = keys_page_list # Users keys that are currently in the page values["all_keys"] = all_keys # All user keys values[ "all_users"] = all_users # ALL user (for the search field) del pages_to_show, pages, users, num_total # Delete variables to free memory # If wasn't successfully added else: del user, 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) # If not exists else: del user # Delete variables to free memory # Variables to be sent to the HTML page values["error_message"] = lang[ "user_already_exists"] # Error message (User already exists) # Else show an error message else: # Values to be sent to the HTML page values["error_message"] = lang[ "must_insert_all_user_attributes"] # Error message (You must enter all user data) del lang, name, offset, keys_page_list, aux_all_keys, all_keys, all_users, aux, aux3, email, \ password1, password2, genre, role, picture # Delete variables to free memory self.session_store.save_sessions(self.response) # Save sessions self.response.write( jinja.render_template("/users/default.html", **values)) # Go to the users home page # If it isn't logged in, redirect to the login page else: self.redirect("/login")
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")
def add_user(email=None, password=None, ip=''): new_user = User(email=email, password=hashing_sha224(password)) db_session.add(new_user)
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 user keys list users = None # Users list all_users = list() # ALL users (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 user 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 users = User.query() all_users = copy.copy( users) # ALL users (for the search field) all_users = all_users.fetch() aux = list() for user in users: # Get ALL the keys aux.append(user.key.urlsafe()) del user 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 users (Limited to the number given by the session variable [10 by default]) # Not ordered because it has to respect if the user used some ordination or filter users = User.query(User.key.IN(all_keys)) # If there is a list of users and a sort option if len(filter_by) > 0 and users is not None: ok_message = lang[ "filtered_by"] + ": " # Ok message (filters applied) for i in range(0, len(filter_by)): # Filter the user list if filter_by[i] == "male" or filter_by[ i] == "female" or filter_by[i] == "not_defined": users = User.query(User.key.IN(all_keys)).filter( User.genre == filter_by[i]) # Genre male or female elif filter_by[i] == "admin" or filter_by[i] == "client": users = User.query(User.key.IN(all_keys)).filter( User.role == filter_by[i]) # Role admin or client # Setting the all user keys list all_keys = list() aux_all_keys = list() if users.count() > 0: for user in users: aux_all_keys.append(user.key.urlsafe()) all_keys.append(user.key) del user users = users.fetch(self.session.get('num_elems_page') ) # Setting the first page to show else: users = 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 (users) 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 user keys list (only on the current page) keys_page_list = list() for user in users: keys_page_list.append(user.key.urlsafe()) del user # 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 "users": users, # Users "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, # Users keys that are currently in the page "all_keys": all_keys, # All user keys "all_users": all_users, # ALL user (for the search field) "ok_message": ok_message # Ok message (filters applied) } del filter_by, aux_all_keys, all_keys, users, lang, keys_page_list, pages,\ num_total, num_pages, num_elems_page, all_users, ok_message # Delete variables to free memory self.session_store.save_sessions( self.response) # Save sessions self.response.write( jinja.render_template( "/users/default.html", **values)) # Go to the users home page # Else redirect to the users home page else: del filter_by, aux_all_keys, all_keys, users # Delete variables to free memory self.redirect("/users") # If it isn't logged in, redirect to the login page else: self.redirect("/login")
def post(self): jinja = jinja2.get_jinja2(app=self.app) # Retrieve the email and password written in the login email = self.request.get("email", "") # Email email = email.encode("utf8") password = self.request.get("password", "") # Password password = password.encode("utf8") # Set the default language of the app lang = get_default_language() # Get the default language of the app # Set the language strings dictionary if lang == "spa": lang = spa # Spanish strings elif lang == "eng": lang = eng # English strings # Set the default values to be sent to the HTML page values = { "lang": lang # Strings } # Check if the email or password fields are empty (HTML shouldn't allow this). Show an error message if they are empty if len(email) == 0 or len(password) == 0: # Value to be sent to the HTML page values["error_message"] = lang[ "needs_email_pass"] # Error message (Password and email required) del email, password # Delete variables to free memory self.response.write(jinja.render_template( "index.html", **values)) # Go to the login page # If not empty else: # Check if the user exists user = User.query(User.email == email) if user and user.count() > 0: # Codify the password hash = encryptPassword(password) # If the user exists, check the email and password. If they are correct, set session variables and redirect tho the home page user = User.query(User.email == email, User.password == hash) if user and user.count() == 1: user = user.fetch() user = user[0] # If the user isn't blocked if user.blocked == False: # Setting the session variable self.session['session_name'] = user.name # User name self.session['session_role'] = user.role # User role self.session[ 'session_idiom'] = user.language # User language strings self.session[ 'session_genre'] = user.genre # User genre self.session[ 'num_elems_page'] = 10 # Number of elements per page self.session[ 'current_number_page'] = 1 # Current number page self.session['pages'] = list( ) # Pages for the pagination self.session['last_page'] = 1 # Last page number self.session[ 'pages_to_show'] = 3 # Number of pages that shows the pagination self.session[ 'page_name'] = "" # Name of the current page in wich user is del user, email, password, hash # Delete variables to free memory self.redirect("/home") # Redirect to the home page # If the user continue with a block else: now = date.today() # If the block is not over if user.blocked == True: if now <= user.end_block: # Value to be sent to the HTML page # Error message (User blocked) values["error_message"] = lang[ "blocked_" + user.genre] + lang["until"] + str( user.end_block + timedelta(days=1)) del user, email, password, hash, now # Delete variables to free memory self.response.write( jinja.render_template( "index.html", **values)) # Go to the login page # Else else: # Unblocking the user user.end_block = None user.blocked = False user.put() # Setting the user # Setting the session variable self.session[ 'session_name'] = user.name # User name self.session[ 'session_role'] = user.role # User role self.session[ 'session_idiom'] = user.language # User language strings self.session[ 'session_genre'] = user.genre # User genre self.session[ 'num_elems_page'] = 10 # Number of elements per page self.session[ 'current_number_page'] = 1 # Current number page self.session['pages'] = list( ) # Pages for the pagination self.session['last_page'] = 1 # Last page number self.session[ 'pages_to_show'] = 3 # Number of pages that shows the pagination self.session[ 'page_name'] = "" # Name of the current page in wich user is del user, email, password, hash # Delete variables to free memory self.redirect("/home") # Redirect to the home page # If they aren't correct show an error message else: # Value to be sent to the HTML page values["error_message"] = lang[ "email_pass_incorrect"] # Error message (Email or password are wrong) del user, email, password, hash # Delete variables to free memory self.response.write( jinja.render_template( "index.html", **values)) # Go to the login page # If the user doesn't exist, show an error message else: # Value to be sent so the HTML page values["error_message"] = lang[ "user_not_exist"] # Error message (That user doesn't exist) del user, email, password # Delete variables to free memory self.response.write( jinja.render_template("index.html", **values)) # Go to the login page
def post(self): jinja = jinja2.get_jinja2(app=self.app) # Retrieve the fields written in the sign in form email = self.request.get("s_email", "") # New user email email = email.encode("utf8") password1 = self.request.get("s_password", "") # New user password password1 = password1.encode("utf8") password2 = self.request.get("rs_password", "") # New user password password2 = password2.encode("utf8") name = self.request.get("s_name", "") # New user name name = name.encode("utf8") genre = self.request.get("s_genre", "not_defined") # New user genre genre = genre.encode("utf8") # Set the default language of the app lang = get_default_language() # Get the default language of the app # Set the language strings dictionary if lang == "spa": lang = spa # Spanish strings elif lang == "eng": lang = eng # English strings # Default values to be sent to the HTML page values = { "lang": lang, # Strings } # Check if the email or password fields are empty (HTML shouldn't allow this). Show an error message if they are empty if len(email) == 0 or len(password1) == 0 or len(password2) == 0: # Values to be sent to the HTML page values["error_message"] = lang[ "needs_email_pass"] # Error message (Email and password required) del email, password1, password2, name, genre # Delete variables to free memory self.response.write(jinja.render_template( "index.html", **values)) # Go to the login page # If not empty else: # Check if the user already exists user = User.query(User.email == email) # If the user exists, show an error message if user and user.count() > 0: # Values to be sent to the HTML page values["error_message"] = lang[ "user_already_exists"] # Error message (This user already exists) del user, email, password1, password2, name, genre # Delete variables to free memory self.response.write( jinja.render_template("index.html", **values)) # Go the login page # If the user doesn't exist, create a new user else: # Check if the username already exists username = User.query(User.name == name) # If the username already exists, shows an error message if username.count() > 0: # Values to be sent to the HTML page values["error_message"] = lang[ "username_already_exists"] # Error message (Username already used by other) del username # Delete variable to free memory self.response.write( jinja.render_template( "index.html", **values)) # Go to the login page # If the username doesn't exist else: # If the passwords are equals if self.check_passwords(password1, password1): # Create an username if the user didn't write one if len(name) == 0: pos = email.find("@") name = email[:pos] # Check if the new user name already exists aux_user = User.query(User.name == name).fetch() aux_name = name while len(aux_user) > 0: aux_name = name + str(random.randint(0, 999)) aux_user = User.query( User.name == aux_name).fetch() name = aux_name # Setting the new user name del pos, aux_user, aux_name # Delete variables to free memory # Codify the password hash = encryptPassword(password1) # Check the genre if genre != "male" and genre != "female" and genre != "female": genre = "not_defined" # Get the default language idiom = get_default_language() # Create the user and put it in in the database user = User(email=email, password=hash, name=name, genre=genre, role="client", language=idiom) aux = user.put() time.sleep(1) # It the user was successfully added if aux is not None: # Setting the session variables self.session[ 'session_name'] = user.name # User name self.session[ 'session_role'] = user.role # User role self.session[ 'session_idiom'] = user.language # User language self.session[ 'session_genre'] = user.genre # User genre self.session[ 'num_elems_page'] = 10 # Number of elements per page self.session[ 'current_number_page'] = 1 # Current number page self.session['pages'] = list( ) # Pages for the pagination self.session['last_page'] = 1 # Last page number self.session[ 'pages_to_show'] = 3 # Number of pages that shows the pagination self.session[ 'page_name'] = "" # Name of the current page in wich user is # Create a welcome email message = mail.EmailMessage( sender= "*****@*****.**", # Email sender, it has to be a Google account subject=lang["welcome_subject"] ) # Email subject message.to = email # Email receiver message.body = lang["welcome_mail"] # Email body # Send the email message.send() del user, email, password1, password2, name, genre, hash, username, idiom, message, aux # Delete variables to free memory self.redirect("/home") # Redirect to the home page # Else show an error message else: # Variables to be sent to the HTML page values["error_message"] = lang[ "error_sign_in"] # Error message (The client couldn't be added) del user, email, password1, password2, name, genre, hash, username, idiom, aux # Delete variables to free memory self.response.write( jinja.render_template( "index.html", **values)) # Go to the login page # If password not equals else: # Variables to be sent to the HTML page values["error_message"] = lang[ "invalid_password"] # Error message (Password not equals) del user, email, password1, password2, name, genre, username # Delete variables to free memory self.response.write( jinja.render_template( "index.html", **values)) # Go to the login page
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 user keys list users = list() # Users list aux3 = list() # All user keys support list all_users = list() # ALL users (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 users (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 user keys list # Check if the users 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 users = User.query() all_users = copy.copy( users) # ALL users (for the search field) all_users = all_users.fetch() aux = list() for user in users: # Get ALL the keys aux.append(user.key.urlsafe()) del user 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 users (Limited to the number given by the session variable [10 by default]) # Not ordered because it has to respect if the user used some ordination or filter users = User.query(User.key.IN(all_keys)).fetch( num_elems_page, offset=offset) num_total = len(aux_all_keys) # Total number of elements # Setting all the user 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 user in users: keys_page_list.append(user.key.urlsafe()) del user # 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 "users": users, # Users "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, # Users keys that are currently in the page "all_keys": all_keys, # All user keys "all_users": all_users # ALL user (for the search field) } del pages_to_show, page_number, num_elems_page, num_total, offset, \ num_pages, current_number_page, pages, keys_page_list, users, aux_all_keys, all_keys,\ all_users # Delete variables to free memory self.session_store.save_sessions( self.response) # Save sessions self.response.write( jinja.render_template( "/users/default.html", **values)) # Go to the users home page # If it isn't less redirect to users home page else: del pages_to_show, page_number, pages, num_elems_page, num_total, offset, users, num_pages, \ aux_all_keys, all_users # Delete variables to free memory self.redirect("/users") # If the total number is not above 0, redirect to the users home page else: del pages_to_show, page_number, pages, offset, users, num_elems_page, aux_all_keys # Delete variables to free memory self.redirect("/users") # If it isn't above redirect to users home page else: del pages_to_show, page_number, pages # Delete variables to free memory self.redirect("/users") # If it isn't logged in, redirect to the login page else: self.redirect("/login")
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 email = self.request.get("email", "") # User email email = email.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 email to change if user is not None and len(email) > 0: repeated_user = User.query(User.email == email) # If it doesn't exist an user with the email provided if repeated_user.count() == 0: # Set the new email user.email = email aux = user.put() time.sleep(1) # If the modification was successful if aux is not None: # Variables to be sent to the HTML page values["ok_message"] = lang[ "email_modified_successfully"] # Ok message (Email modified successfully) values["user_email"] = user.email # 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 # 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[ "user_already_exists"] # Error message (User already exists) del repeated_user # Delete variables to free memory # Else show an error message else: # Values to be sent to the HTML page values["error_message"] = lang[ "email_not_modified"] # Error message (Email couldn't be modified) del lang, email, 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")
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 user keys keys_page_list = list() # User keys currently in the page # Get all db users (Limited to the number given by the session variable [10 by default]) users = User.query().order(User.name) # All users ordered by name all_users = copy.copy(users) # ALL users (for the search field) all_users = all_users.fetch() num_total = len(all_users) # Total number of elements self.session['page_name'] = "/users" # Current page name self.session['num_elems_page'] = 10 # Amount of elements # Get ALL the user keys (they are necessary to do the order and filter) for user in users: all_keys.append(user.key.urlsafe()) del user # 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 (users) per page num_pages = num_total / num_elems_page # Number of pages users = users.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 user in users: keys_page_list.append(user.key.urlsafe()) del user del num_elems_page, num_pages, current_number_page, pages # Delete variables to free memory # If num_total < 0 else: users = all_users # 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 "users": users, # Users "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, # Users keys that are currently in the page "all_keys": all_keys, # All user keys "all_users": all_users # ALL users (for the search field) } del num_total, pages_to_show, keys_page_list, all_keys, lang, users, all_users # Delete variables to free memory self.session_store.save_sessions(self.response) # Save sessions self.response.write( jinja.render_template("/users/default.html", **values)) # Go to the users home page # If it isn't logged in, redirect to the login page else: self.redirect("/login")
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 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() users = list() pages = list() keys_page_list = list() all_users = User.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 "users": users, # Users "current_number_page": self.session.get('current_number_page'), # 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, # Users keys that are currently in the page "all_keys": all_keys, # All user keys "all_users": all_users # ALL user (for the search field) } # 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 users with that key user = key.get() # Check if the users exists if user and user is not None: users.append(user) # Users list values["users"] = users # Search results # Setting all the user keys all_keys.append(user.key.urlsafe()) values["all_keys"] = all_keys # Setting the keys list to allow the use of the "Delete page" button keys_page_list.append(user.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, user # 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, users, pages, keys_page_list, all_keys, lang, all_users # Delete variables to free memory self.response.write(jinja.render_template("/users/default.html", **values)) # Go to the users home page # If it isn't logged in, redirect to the login page else: self.redirect("/login")
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")
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 user attributes key = self.request.get("key", "") key = ndb.Key(urlsafe=key) user = key.get() # Get the user with that key keys_page_list = self.request.get( "keys_page_list", "") # User keys (only users in the current page) aux_all_keys = self.request.get( "all_keys", "") # All the user keys (for the order field) # Initialize variables aux = list() # Support variable aux3 = list() # Support variable all_users = list() # List with all users (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) users = User.query() for user2 in users: # Get ALL the keys aux.append(user2.key.urlsafe()) del user2 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 users offset = (self.session.get('current_number_page') - 1) * self.session.get('num_elems_page') users = User.query(User.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 "users": users, # Users "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, # Users keys that are currently in the page "all_keys": all_keys, # All user keys "all_users": all_users # ALL user (for the search field) } # If the key is from an user if user and user is not None: user.blocked = False user.end_block = None # Set the user aux2 = user.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[ "user_unblocked_successfully"] # Ok message (User unblocked successfully) # Get all db users (Limited to the number given by the session variable [10 by default]) users = User.query(User.key.IN(aux3)).fetch( self.session.get('num_elems_page'), offset=offset) values["users"] = users # Else show an error message else: # Variables to be sent to the HTML page values["error_message"] = lang[ "error_unblock"] # Error message (The unblock 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[ "user_not_unblocked"] # Error message (User couldn't be unblocked) all_users = User.query().fetch( ) # ALL users (for the search field) values["all_users"] = all_users del lang, key, user, keys_page_list, aux_all_keys, aux, aux3, users, \ all_users, offset, all_keys # Delete variables to free memory self.session_store.save_sessions(self.response) # Save sessions self.response.write( jinja.render_template("/users/default.html", **values)) # Go to the users home page # If it isn't logged in, redirect to the login page else: self.redirect("/login")
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")
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")