def validate_and_save(self, update=False, pdf=None):
"""
Valida que el centro creado/modificado tenga formato válido.
Si es válido lo actualiza en la base de datos, caso contrario
devuelve los errores que existieron en las validaciones.
"""
errors = ""
self.web = sql_and_tag_escape(self.web)
self.name = sql_and_tag_escape(self.name)
self.address = sql_and_tag_escape(self.address)
self.municipio = sql_and_tag_escape(self.municipio)
errors += self.validate_name()
errors += self.validate_address()
errors += self.validate_email()
errors += self.validate_phone()
errors += self.validate_url()
errors += self.validate_opens_closes()
errors += self.validate_coordinates()
errors += self.validate_municipio()
errors += self.validate_protocol(pdf)
if not update:
db_session.add(self)
if errors:
raise AssertionError(errors)
db_session.commit()
def index():
"""
Muestra la barra de busqueda de turnos,
por defecto busca turnos que aun no pasaron y por email
"""
query = Turno.query
searchQ = {}
page = request.args.get("page")
buscar = request.args.get("buscar")
tipo = request.args.get("tipo_busqueda")
searchQ["tipo"] = tipo
if buscar:
buscar = sql_and_tag_escape(buscar)
searchQ["buscar"] = buscar
if tipo == "email":
query = query.filter(Turno.email.like(f"%{buscar}%"))
elif tipo == "nombre_centro":
query = query.join(Center).filter(Center.name.like(f"%{buscar}%"))
antiguos = request.args.get("antiguos")
searchQ["antiguos"] = "checked" if antiguos else ""
if not antiguos:
query = query.filter(Turno.date >= datetime.now().date())
else:
query = query.filter(Turno.id == -1)
centers = {c.id: c.name for c in Center.query.all()}
return render_template('turn/index.html',
turns=paginate(query, page),
total_pages=number_of_pages(query),
current_page=get_page(page),
searchQ=searchQ,
centros=centers)
def index():
"""
Vista del listado de usuarios, retorna los usuarios paginados y filtra
a partir de los argumentos de busqueda si hay alguno
"""
query = User.query
searchQ = {}
activos = request.args.get("no_activos")
if not activos:
query = query.filter(User.activo == "1")
busqueda = request.args.get("username")
if busqueda:
busqueda = sql_and_tag_escape(busqueda)
query = query.filter(User.username.like("%" + busqueda + "%"))
else:
busqueda = ""
searchQ["busqueda"] = busqueda
searchQ["no_activo"] = "checked" if activos else ""
page = request.args.get("page")
return render_template("user/index.html",
users=paginate(query, page),
total_pages=number_of_pages(query),
current_page=get_page(page),
searchQ=searchQ)
def index():
"""
Retorna todos los centros aprobados para su publicacion, paginados a
partir los parametros de la request
"""
query = Center.query
searchQ = {}
estado = request.args.get("estado")
if not estado:
query = query.join(State).filter(State.name == "Aprobado")
else:
query = query.join(State).filter(State.name == estado)
busqueda = request.args.get("busqueda")
if busqueda:
busqueda = sql_and_tag_escape(busqueda)
query = query.filter(Center.name.like("%" + busqueda + "%"))
else:
busqueda = ""
searchQ["busqueda"] = busqueda
searchQ["estado"] = estado
page = request.args.get("page")
estados = State.query.all()
return render_template(
'center/index.html',
centros=paginate(query, page),
total_pages=number_of_pages(query),
current_page=get_page(page),
searchQ=searchQ,
estados=estados,
)
def validate_phone(self):
"""
Valida el numero de telefono, devuelve un string vacio si es valido
"""
self.phone_number = sql_and_tag_escape(self.phone_number)
phone = self.phone_number.replace('+', '').replace('(', '').replace(
')', '').replace('-', '').replace(' ', '')
if not (phone.isnumeric()) or not (9 < len(phone) < 17):
return "Numero de telefono invalido,"
return ""
def destroy(id):
"""
Elimina un turno especifico de la base de datos
"""
turno = Turno.query.filter_by(id=sql_and_tag_escape(str(id))).first()
if not turno:
abort(404)
db_session.delete(turno)
db_session.commit()
return redirect(url_for('turns.index'))
def validate_phone_number(turno):
"""
Valida que el turno pasado por parametro tenga un formato valido
"""
turno.phone_number = sql_and_tag_escape(turno.phone_number)
phone = turno.phone_number.replace('+', '').replace('(', '').replace(
')', ''
).replace('-', '').replace(' ', '')
if not (phone.isnumeric()) or not (9 < len(phone) < 17):
return "Numero de telefono invalido,"
return ""
def show(id):
"""
Muestra un turno en especifico (por id)
"""
turno = Turno.query.filter_by(id=sql_and_tag_escape(str(id))).first()
if not turno:
abort(404)
return render_template(
'turn/show.html',
turno=turno,
centro=(Center.query.filter_by(id=turno.center).first().name))
def update():
"""
Actualiza la configuracion a partir de los campos rellenados en el
formulario de configuracion o flashea un mensaje de error si falla
alguna validacion
"""
if(check_token(request.form["csrf_token"])):
CSRF_TOKEN = request.form["csrf_token"]
form = request.form.copy()
if "home.habilitado" in request.form.keys():
form["home.habilitado"] = "TRUE"
else:
form["home.habilitado"] = "FALSE"
errors = ""
del form["csrf_token"]
for element in form:
original = Configuration.query.filter_by(name=element).first()
original.value = sql_and_tag_escape(form[element])
error = validate(original)
if error:
errors += error
if not errors:
flash("Configuración guardada correctamente", "success")
db_session.commit()
return redirect(url_for("configuration.index"))
else:
flash_messages(errors)
configurations = Configuration.query.order_by(
Configuration.name
).all()
configs = {}
first_name = ''
for element in configurations:
name = element.name.split('.')
if first_name != name[0]:
first_name = name[0]
configs_content = []
configs[name[0]] = configs_content
content_elements = [element.name, form[element.name]]
configs[name[0]].append(content_elements)
return(render_template(
"configuration/configuration.html",
configs=configs,
CSRF_TOKEN_STRING=CSRF_TOKEN
))
else:
return render_template("configuration/configuration.html")
def pending_index():
"""
Vista que permite ver únicamente los centros en estado Pendiente
"""
centers = Center.query.join(State).filter(State.name == "Pendiente")
search = request.args.get("busqueda")
if search:
search = sql_and_tag_escape(search)
centers = centers.filter(Center.name.like("%" + search + "%"))
else:
search = ""
page = request.args.get("page")
return render_template(
'center/pending.html',
centros=paginate(centers, page),
total_pages=number_of_pages(centers),
current_page=get_page(page),
search=search,
)