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")
