def get(self):
try:
id = self.request.GET['ticket_id']
except KeyError:
self.redirect("/error?msg=ticket was not found")
return
usr = users.get_current_user()
usr_info = usr_mgt.retrieve(usr)
if usr and usr_info:
access_link = users.create_logout_url("/")
try:
ticket = ndb.Key(urlsafe=id).get()
except:
self.redirect("/error?msg=key #" + id + " does not exist")
return
template_values = {
"info": AppInfo,
"usr_info": usr_info,
"access_link": access_link,
"ticket": ticket,
"Status": Ticket.Status,
"Progress": Ticket.Progress,
"Priority": Ticket.Priority,
"Type": Ticket.Type,
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(
jinja.render_template("modify_ticket.html", **template_values))
else:
self.redirect("/")
def get(self):
imagen, likes = Like.recupera_para(self.request)
usuarios = []
usr = users.get_current_user()
url_usr = users.create_logout_url("/")
usr_info = mgt_usr.retrieve(usr)
for like in likes:
clave_usr = like.usuario
print("EL PRINT ESTA AQUI!!!!!!", like)
usuarios.append(clave_usr.get())
valores_plantilla = {
"likes": likes,
"usuarios": usuarios,
"imagen": imagen,
"usr_info": usr_info,
"usr": usr_info,
"url_usr": url_usr
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(
jinja.render_template("lista_likes.html", **valores_plantilla))
def get(self):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
user_admin_set = User.query(
User.level == User.Level.Admin).order(-User.added)
user_staff_set = User.query(User.level != User.Level.Admin).order(
User.level).order(-User.added)
user_set = list(user_admin_set) + list(user_staff_set)
access_link = users.create_logout_url("/")
if not (usr_info.is_admin()):
self.redirect("/error?msg=User " + usr_info.nick +
" not allowed to manage users")
return
template_values = {
"info": AppInfo,
"usr_info": usr_info,
"access_link": access_link,
"users": user_set,
"Level": User.Level,
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(
jinja.render_template("users.html", **template_values))
else:
self.redirect("/")
return
def get(self):
usr = users.get_current_user()
user = user_model.retrieve(usr)
if usr and user:
like = UserLike()
like.usr_email = user.email
like.videojuego = Videojuego.recupera(self.request).key
if user_like.can_be_created_like(like):
print("Like dado")
time.sleep(1)
return self.redirect("/")
elif user_like.can_delete_like(like):
print("Like borrado")
time.sleep(1)
return self.redirect("/")
else:
print("no se pudo insertar o eliminar like")
time.sleep(1)
return self.redirect("/")
else:
print("Volviendo a la raiz, user no identificado en add_modify like")
time.sleep(1)
return self.redirect("/")
def get(self):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
comments = comment_mgt.create_query_all_for_user(usr_info)
books = list()
for comment in comments:
books.append(book_mgt.create_query_isbn(comment.isbn))
access_link = users.create_logout_url("/")
likes = like_mgt.create_query_all_for_one_user(usr_info.email)
like_list = list()
for like in likes:
like_list.append(like.isbn)
template_values = {
"info": AppInfo,
"access_link": access_link,
"books": books,
"usr_info": usr_info,
"likes": like_list
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(
jinja.render_template("books.html", **template_values))
else:
self.redirect("/")
return
def post(self):
try:
id = self.request.GET['user_id']
except:
id = None
if not id:
self.redirect("/error?msg=missing id for modification")
return
user = users.get_current_user()
if user:
usr_info = usr_mgt.retrieve(user)
if not (usr_info.is_admin()):
self.redirect("/error?msg=user " + usr_info.email +
"not allowed to delete users")
return
# Get user to delete by key
try:
user_to_delete = ndb.Key(urlsafe=id).get()
except:
self.redirect("/error?msg=key #" + id + " does not exist")
return
# Delete
user_to_delete.key.delete()
self.redirect("/info?url=/manage_users&msg=User deleted: " +
user_to_delete.email.encode("ascii", "replace"))
else:
self.redirect("/")
def get(self):
usr = users.get_current_user()
user = user_model.retrieve(usr)
if usr and user:
juegos_like = like_model.get_juegos_like(user.email)
videojuegos = Videojuego.query().order()
keys_fav = []
for userlike in juegos_like:
keys_fav.append(userlike.videojuego.urlsafe())
valores_plantilla = {
"keys_fav": keys_fav,
"videojuegos": videojuegos,
"usr": usr,
"user": user
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(
jinja.render_template("show_all_likes.html",
**valores_plantilla))
else:
print("else show all likes, redireccionando")
return self.redirect("/")
def get(self):
usr = users.get_current_user()
user = user_model.retrieve(usr)
if usr and user:
usr_url = users.create_logout_url("/")
else:
user = user_model.create_empty_user()
user.nick = "Login"
usr_url = users.create_login_url("/")
videojuegos = Videojuego.query().order()
juegos_like = like_model.get_juegos_like(user.email)
juegos_key_list = []
for juego in juegos_like:
juegos_key_list.append(juego.videojuego.urlsafe())
print("juegos_key_list= {0}".format(juegos_key_list))
valores_plantilla = {
"videojuegos": videojuegos,
"juegos_key_list": juegos_key_list,
"usr": usr,
"usr_url": usr_url,
"user": user
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(jinja.render_template("index.html", **valores_plantilla))
def get(self):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
books = book_mgt.create_query_all()
access_link = users.create_logout_url("/")
likes = like_mgt.create_query_all_for_one_user(usr_info.email)
like_list = list(likes)
for like in likes:
like_list.append(like.isbn)
for book in books:
cant_likes = like_mgt.cant_likes(book.isbn)
if cant_likes != book.likes:
book.likes = cant_likes
book_mgt.update(book)
template_values = {
"info": AppInfo,
"access_link": access_link,
"books": books,
"usr_info": usr_info,
"likes": like_list
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(
jinja.render_template("books.html", **template_values))
else:
self.redirect("/")
return
def post(self):
try:
id = self.request.GET['ticket_id']
except KeyError:
id = None
if not id:
self.redirect("/error?msg=missing id for modification")
return
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
# Get ticket by key
try:
ticket = ndb.Key(urlsafe=id).get()
except KeyError:
self.redirect("/error?msg=key " + id + " does not exist")
return
ticket.title = self.request.get("title", "").strip()
ticket.desc = self.request.get("desc", "").strip()
ticket.client_email = self.request.get("client_email", "").strip()
ticket.classroom = self.request.get("classroom", "").strip()
ticket.progress = Ticket.Progress.value_from_str(
self.request.get("progress"))
ticket.status = Ticket.Status.value_from_str(
self.request.get("status"))
ticket.priority = Ticket.Priority.value_from_str(
self.request.get("priority"))
ticket.type = Ticket.Type.value_from_str(self.request.get("type"))
if (not ticket.client_email and usr_info.is_client()):
ticket.client_email = usr_info.email
# Chk
if len(ticket.title) < 1:
self.redirect("/error?msg=Aborted modification: missing title")
return
if len(ticket.desc) < 1:
self.redirect("/error?msg=Aborted modification: missing desc")
return
# Report
tickets.send_email_for(ticket, "modified",
" modified by: " + unicode(usr_info))
# Save
ticket.born = True
tickets.update(ticket)
self.redirect("/info?url=/manage_tickets&msg=Ticket modified: " +
ticket.title.encode("ascii", "replace"))
else:
self.redirect("/")
def get(self):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
key = tickets.update(tickets.create(usr_info))
self.redirect("/tickets/modify?ticket_id=" + key.urlsafe())
else:
self.redirect("/")
return
def post(self, isbn):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
like = like_mgt.create(usr_info)
like.isbn = int(isbn)
like_mgt.can_be_created(like)
sleep(2)
self.redirect("/books")
else:
self.redirect("/")
def post(self, isbn):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
like = like_mgt.create(usr_info)
like.isbn = int(isbn)
like_mgt.create_query_delete_one(like)
self.redirect("/books")
else:
self.redirect("/")
def post(self, isbn):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
comment = comment_mgt.create(usr_info)
comment.isbn = int(isbn)
comment.comment = self.request.get("comment", "").strip()
comment_mgt.update(comment)
sleep(1)
self.redirect("/book/" + isbn)
else:
self.redirect("/")
def get(self):
imagen = Imagen.recupera(self.request)
usr = users.get_current_user()
url_usr = users.create_logout_url("/")
usr_info = mgt_usr.retrieve(usr)
valores_plantilla = {
"imagen": imagen,
"usr_info": usr_info,
"usr": usr,
"url_usr": url_usr
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(jinja.render_template("nuevo_like.html", **valores_plantilla))
def get(self):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
if not (usr_info.is_admin()):
self.redirect("/error?msg=user " + usr_info.email +
"not allowed to add new users")
return
key = usr_mgt.update(usr_mgt.create(user, User.Level.Staff))
self.redirect("/users/modify?user_id=" + key.urlsafe())
else:
self.redirect("/")
return
def post(self):
try:
id = self.request.GET['user_id']
except:
id = None
if not id:
self.redirect("/error?msg=missing id for modification")
return
user = users.get_current_user()
if user:
usr_info = usr_mgt.retrieve(user)
if not (usr_info.is_admin()):
self.redirect("/error?msg=user " + usr_info.email +
" not allowed to modify other users")
# Get user by key
try:
user_to_modify = ndb.Key(urlsafe=id).get()
except:
self.redirect("/error?msg=key #" + id + " does not exist")
return
user_to_modify.email = self.request.get("email", "").strip()
user_to_modify.nick = self.request.get("nick", "").strip()
user_to_modify.level = User.Level.value_from_str(
self.request.get("level", "Client").strip())
# Chk
if len(user_to_modify.email) < 1:
self.redirect("/error?msg=Aborted modification: missing email")
return
if len(user_to_modify.nick) < 1:
self.redirect("/error?msg=Aborted modification: missing nick")
return
# Save
usr_mgt.update(user_to_modify)
self.redirect("/info?url=/manage_users&msg=User modified: " +
user_to_modify.email.encode("ascii", "replace"))
else:
self.redirect("/")
def post(self):
imagen = self.request.GET["id"]
nombre = self.request.get("edNombre", "")
email = self.request.get("edEmail", "")
if len(nombre) < 0 or not(nombre) or len(email) < 0 or not(email):
return self.redirect("/")
else:
usr = users.get_current_user()
user = mgt_usr.retrieve(usr)
print("EL PRINT ESTA AQUI!!!!!", user.key)
like = Like(usuario=user.key, imagen=ndb.Key(urlsafe=imagen))
like.put()
time.sleep(1)
return self.redirect("/")
def get(self):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info and usr_info.is_admin():
self.csv_content = ""
tickets = Ticket.query(
Ticket.type == Ticket.Type.Supplies).order(-Ticket.added)
tickets.map(self.add_csv_row)
self.response.headers['Content-Type'] = "text/csv"
self.response.headers[
'Content-Disposition'] = "attachment; filename=supplies.csv"
self.response.write(self.csv_content)
else:
self.redirect("/")
return
def get(self):
usr = users.get_current_user()
usr_info = usr_mgt.retrieve(usr)
if usr and usr_info:
access_link = users.create_logout_url("/")
template_variables = {
"info": AppInfo,
"usr_info": usr_info,
"access_link": access_link,
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(
jinja.render_template("toner.html", **template_variables))
else:
self.redirect("/")
def get(self):
try:
id = self.request.GET['ticket_id']
except:
self.redirect("/error?msg=ticket was not found")
return
usr = users.get_current_user()
usr_info = usr_mgt.retrieve(usr)
if usr and usr_info:
access_link = users.create_logout_url("/")
try:
ticket = ndb.Key(urlsafe=id).get()
except:
self.redirect("/error?msg=key " + id + " does not exist")
return
if (usr_info.email != ticket.owner_email and usr_info.is_client()):
self.redirect("/error?msg=User " + usr_info.email +
" not allowed to check tickets")
return
template_values = {
"info": AppInfo,
"usr_info": usr_info,
"access_link": access_link,
"ticket": ticket,
"comments": ticket.comments,
"Status": Ticket.Status,
"Progress": Ticket.Progress,
"Priority": Ticket.Priority,
"Type": Ticket.Type,
"MinCommentLength": ChkTicket.MinCommentLength
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(
jinja.render_template("chk_ticket.html", **template_values))
else:
self.redirect("/")
def get(self, isbn):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
comments = comment_mgt.create_query_all_for_one_isbn(isbn)
if user and usr_info:
book = book_mgt.create_query_isbn(isbn)
access_link = users.create_logout_url("/")
template_values = {
"info": AppInfo,
"access_link": access_link,
"book": book,
"comments": comments,
"usr_info": usr_info
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(
jinja.render_template("show_current_book.html",
**template_values))
def get(self):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
self.redirect("/manage_tickets")
return
else:
usr_info = usr_mgt.create_empty_user()
usr_info.nick = "Login"
access_link = users.create_login_url("/manage_tickets")
template_values = {
"info": AppInfo,
"usr_info": usr_info,
"access_link": access_link
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(
jinja.render_template("index.html", **template_values))
def get(self):
try:
id = self.request.GET['user_id']
except:
self.redirect("/error?msg=user was not found")
return
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
if not (usr_info.is_admin()):
self.redirect("/error?msg=User " + user.email +
" not allowed to delete users")
return
access_link = users.create_logout_url("/")
try:
user_to_delete = ndb.Key(urlsafe=id).get()
except:
self.redirect("/error?msg=key #" + id + " does not exist")
return
template_values = {
"info": AppInfo,
"access_link": access_link,
"usr_info": usr_info,
"user_to_delete": user_to_delete,
"user_desc": user_to_delete,
"Level": User.Level,
}
jinja = jinja2.get_jinja2(app=self.app)
self.response.write(
jinja.render_template("delete_user.html", **template_values))
else:
self.redirect("/")
return
def post(self):
self.response.write("Formulario recibido, registrando videojuego")
titulo = self.request.get("addTitulo", "falta titulo")
sinopsis = self.request.get("addSinopsis", "")
str_genero = self.request.get("addGenero", "")
str_pegi = self.request.get("addPegi", "")
data_caratula = self.request.get("addCaratula", None)
usr = users.get_current_user()
user = user_model.retrieve(usr)
#DEFINE GENERO DEL JUEGO
genero = Genero.get(str_genero)
print("------------------------------------------")
print("titulo: {0}" "sinopsis: {1}".format(titulo, sinopsis))
print("------------------------------------------")
try:
pegi = int(str_pegi)
pegi = Pegi.get(pegi)
except ValueError:
pegi = -1
#If comprobaciones, redirigir si algo va mal
if not (titulo) or not (sinopsis) or not (genero) or pegi < 0 or not (
data_caratula) or not (user):
return self.redirect("/")
else:
juego = Videojuego(titulo=titulo,
sinopsis=sinopsis,
genero=genero,
pegi=pegi,
caratula=data_caratula,
usr_email=user.email)
juego.caratula = images.resize(data_caratula, 220, 306)
juego.put()
sleep(1)
return self.redirect("/")
def post(self):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
book = book_mgt.create(usr_info)
book.isbn = int(self.request.get("isbn", "").strip())
book.mainComment = self.request.get("mainComment", "").strip()
request = service.volumes().list(q='1')
HttpRequest = request
url = "https://www.googleapis.com/books/v1/volumes?country=US&q=isbn:" + str(
book.isbn) + "&key=" + AppInfo.KeyBooks
HttpRequest.uri = url
response = HttpRequest.execute(http=decorator.http())
if response['totalItems'] > 0:
items = response['items'][0]['volumeInfo']
book.title = items['title']
book.author = items['authors'][0]
book.publisher = items['publisher']
book.year = items['publishedDate'].split("T")[0]
book.description = items['description']
book.img = items['imageLinks']['thumbnail']
valor = book_mgt.can_create(book)
if valor is None:
book_mgt.update(book)
self.redirect("/books")
else:
self.redirect(
"/error?msg=Ya existe ese libro&redirect=/book/add")
else:
self.redirect(
"/error?msg=No existe ese libro&redirect=/book/add")
else:
self.redirect("/")
def get(self):
usr = users.get_current_user()
user = mgt_usr.retrieve(usr)
jinja = jinja2.get_jinja2(app=self.app)
if usr and user:
url_usr = users.create_logout_url("/")
jinja = jinja2.get_jinja2(app=self.app)
imagenes = Imagen.query().order(Imagen.fecha)
valores_plantilla = {
"usr": user,
"url_usr": url_usr,
"imagenes": imagenes
}
self.response.write(
jinja.render_template("index.html", **valores_plantilla))
else:
url_usr = users.create_login_url("/")
valores_plantilla = {"usr": usr, "url_usr": url_usr}
self.response.write(
jinja.render_template("index.html", **valores_plantilla))
def post(self):
try:
id = self.request.GET['ticket_id']
except:
id = None
if not id:
self.redirect("/error?msg=missing id for modification")
return
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
# Get ticket by key
try:
ticket = ndb.Key(urlsafe=id).get()
except:
self.redirect("/error?msg=key #" + id + " does not exist")
return
if (usr_info.email != ticket.owner_email and usr_info.is_client()):
self.redirect("/error?msg=User " + user.email +
" not allowed to check tickets")
return
new_comment = self.request.get("comment", "").strip()
if len(new_comment) >= ChkTicket.MinCommentLength:
ticket.client_email = self.request.get("client_email",
"").strip()
ticket.classroom = self.request.get("classroom", "").strip()
ticket.progress = Ticket.Progress.value_from_str(
self.request.get("progress"))
ticket.status = Ticket.Status.value_from_str(
self.request.get("status"))
ticket.comments.append(
tickets.Comment(author=usr_info.email, text=new_comment))
# Assure the ticket's progress is Fixed when appropriate
if (ticket.status == Ticket.Status.Closed
and (ticket.progress == Ticket.Progress.New
or ticket.progress == Ticket.Progress.Tracked
or ticket.progress == Ticket.Progress.Stalled)):
ticket.progress = Ticket.Progress.Fixed
# Save
tickets.update(ticket)
self.redirect(
"/info?url=/manage_tickets&msg=Ticket checked: " +
ticket.Status.values[ticket.status] + " " +
ticket.Progress.values[ticket.progress] + " " +
ticket.title.encode("ascii", "replace"))
# Report
tickets.send_email_chk_for(
ticket, "checked",
usr_info.email + " says:\n" + new_comment)
else:
self.redirect("/error?msg=Comment should be at least of " +
unicode(ChkTicket.MinCommentLength) + " chars.")
else:
self.redirect("/")
def post(self):
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
# Retrieve values
cartridge_model = self.request.get("cartridge_model", "").strip()
printer_maker = self.request.get("printer_maker", "").strip()
printer_model = self.request.get("printer_model", "").strip()
str_num_units = self.request.get("number_of_units", "").strip()
num_units = 1
# Chk
if len(cartridge_model) < 3:
self.redirect(
"/error?msg=Aborted modification: missing cartridge model")
return
if len(printer_maker) < 2:
self.redirect(
"/error?msg=Aborted modification: missing printer maker")
return
if len(printer_model) < 5:
self.redirect(
"/error?msg=Aborted modification: missing printer model")
return
try:
num_units = int(str_num_units)
except ValueError:
logs.error("Invalid number of units: " + str_num_units)
if (num_units < 1 or num_units > 10):
logs.error("Invalid number of units (1 < units < 10): " +
str_num_units)
# Create ticket
ticket = tickets.create(usr_info)
ticket.progress = Ticket.Progress.Tracked
ticket.status = Ticket.Status.Open
ticket.priority = Ticket.Priority.Low
ticket.type = Ticket.Type.Supplies
ticket.title = "Supplies: toner"
ticket.desc = "Ink cartridge requested for: "\
+ printer_maker + " " + printer_model + '\n'\
+ "Cartridge #" + cartridge_model + "\n"\
+ str(num_units) + " units"
ticket.client_email = ""
ticket.classroom = ""
# Report
tickets.send_email_for(ticket, "Ink cartridge request",
" by " + str(usr_info))
# Save
tickets.update(ticket)
self.redirect(
"/info?url=/manage_tickets&msg=Ink cartridge requested: " +
ticket.title.replace('#', '').encode("ascii", "replace"))
else:
self.redirect("/")
def get(self):
try:
arg_show_all = self.request.GET['show_all']
except KeyError:
arg_show_all = "false"
try:
arg_page = int(self.request.GET['page'])
except KeyError or ValueError:
arg_page = 0
try:
arg_search_terms = self.request.GET['search']
except KeyError:
arg_search_terms = ""
show_all = (arg_show_all == "true")
self.list_search_terms = [
x.lower() for x in arg_search_terms.strip().split()
]
pages_info = {}
user = users.get_current_user()
usr_info = usr_mgt.retrieve(user)
if user and usr_info:
ticket_mgt.clean_unborn()
access_link = users.create_logout_url("/")
# Retrieve the relevant tickets
# This could be made shorter, but I prefer to access the db
# with a query as limited as possible
if usr_info.is_client():
if not show_all:
tickets = ticket_mgt.create_open_tickets_query_for_email(
usr_info.email)
else:
tickets = ticket_mgt.create_query_for_email(usr_info.email)
else:
if not show_all:
tickets = ticket_mgt.create_open_tickets_query_all()
else:
tickets = ticket_mgt.create_query_all()
tickets = tickets.order(-Ticket.added)
if self.list_search_terms:
self.ticket_key_set = []
tickets.map(self.filter_by_search_terms)
tickets = self.ticket_key_set
else:
tickets = tickets.fetch(keys_only=True)
future_tickets = TicketsManager.paginate(tickets, pages_info,
arg_page)
template_values = {
"info": AppInfo,
"access_link": access_link,
"Status": Ticket.Status,
"Priority": Ticket.Priority,
"Progress": Ticket.Progress,
"usr_info": usr_info,
"show_all": show_all,
"search_terms": arg_search_terms,
"pages_info": pages_info
}
jinja = jinja2.get_jinja2(app=self.app)
tickets = [x.get_result() for x in future_tickets]
template_values["tickets"] = tickets
self.response.write(
jinja.render_template("tickets.html", **template_values))
else:
self.redirect("/")
return
