def post(self):
form = ChangePasswordForm(request.form)
if form.validate():
# tengo que buscar el usuario correspondiente y chequear
# que el password sea el correcto
logged_user = get_logged_user_data()
query = Usuario.query
query = query.join(Arquero)
query = query.filter(Arquero.email == logged_user.email)
user = query.first()
if not user:
raise Exception(
'El usuario no existe pero el mismo estaba logueado')
if self.bcrypt.check_password_hash(user.password,
form.password.data):
user.password = self.bcrypt.generate_password_hash(
form.new_password.data)
self.db.session.add(user)
self.db.session.commit()
return redirect(url_for('auth.logout'))
else:
return render_template('change_password.html',
form=form,
invalid_password=True)
else:
return render_template('change_password.html',
form=form,
invalid_password=False)
def post(self):
if self.development:
return jsonify(ok=True)
logged_user = get_logged_user_data()
format_data = dict(
line_number=request.form['lineNumber'],
filename=request.form['url'],
error_message=request.form['errorMessage'],
user_url=request.form['userURL'],
)
mail_content = 'Archivo: {filename}\nLine Number: {line_number}\nMessage: {error_message}\nURL: {user_url}\n'
if 'columnNumber' in request.form:
mail_content += 'Column Number: {column_number}\n'
format_data['column_number'] = request.form['columnNumber']
if 'stacktrace' in request.form:
mail_content += 'Stacktrace: {stacktrace}\n'
format_data['stacktrace'] = request.form['stacktrace']
if logged_user:
mail_content += 'Username: {username}\n'
format_data['username'] = logged_user.email
mail_content = mail_content.format(**format_data)
self.mail_sender.send_mail(self.developers,
'[Sistema-EDA] Javascript Error',
mail_content)
return jsonify(ok=True)
def post(self):
if self.development:
return jsonify(ok=True)
logged_user = get_logged_user_data()
format_data = dict(
line_number=request.form['lineNumber'],
filename=request.form['url'],
error_message=request.form['errorMessage'],
user_url=request.form['userURL'],
)
mail_content = 'Archivo: {filename}\nLine Number: {line_number}\nMessage: {error_message}\nURL: {user_url}\n'
if 'columnNumber' in request.form:
mail_content += 'Column Number: {column_number}\n'
format_data['column_number'] = request.form['columnNumber']
if 'stacktrace' in request.form:
mail_content += 'Stacktrace: {stacktrace}\n'
format_data['stacktrace'] = request.form['stacktrace']
if logged_user:
mail_content += 'Username: {username}\n'
format_data['username'] = logged_user.email
mail_content = mail_content.format(**format_data)
self.mail_sender.send_mail(self.developers,
'[Sistema-EDA] Javascript Error',
mail_content)
return jsonify(ok=True)
def post(self):
form = ChangePasswordForm(request.form)
if form.validate():
# tengo que buscar el usuario correspondiente y chequear
# que el password sea el correcto
logged_user = get_logged_user_data()
query = Usuario.query
query = query.join(Arquero)
query = query.filter(Arquero.email == logged_user.email)
user = query.first()
if not user:
raise Exception('El usuario no existe pero el mismo estaba logueado')
if self.bcrypt.check_password_hash(user.password, form.password.data):
user.password = self.bcrypt.generate_password_hash(form.new_password.data)
self.db.session.add(user)
self.db.session.commit()
return redirect(url_for('auth.logout'))
else:
return render_template('change_password.html',
form=form,
invalid_password=True)
else:
return render_template('change_password.html',
form=form,
invalid_password=False)
def get_instance(self):
res = super(PagoForm, self).get_instance()
logged_user = get_logged_user_data()
res.id_cargado_por = logged_user.id
res.mes_correspondiente = date(res.mes_correspondiente.year,
res.mes_correspondiente.month,
1)
return res
def get(self):
logged_user = get_logged_user_data()
arquero = Arquero.query.filter(
Arquero.id == logged_user.id_arquero).first()
return render_template('change_my_data.html',
form=ArqueroForm(Arquero,
arquero.id,
obj=arquero))
def post(self):
''' Esto es llamadao cuando el usuario quiere crear una instancia.
'''
form = self.form_class(self.model_class)
if form.validate_on_submit():
# si tiene el usuario, entonces se lo tengo que agregar.
if hasattr(self.model_class, 'id_usuario'):
if form.instance.id_usuario is None:
logged_user = get_logged_user_data()
form.instance.id_usuario = logged_user.id
elif hasattr(self.model_class, 'id_arquero'):
if form.instance.id_arquero is None:
logged_user = get_logged_user_data()
form.instance.id_arquero = logged_user.id_arquero
self.db.session.add(form.instance)
self.db.session.commit()
return jsonify(id=form.instance.id)
else:
return jsonify(form.errors), 400
def post(self):
''' Se encarga de crear el usuario siempre y cuando el hash de la envitacion
siga siendo valido..
'''
# primero me fijo que la invitacion exista y que la misma sea valida
form_arquero = ArqueroForm(Arquero)
if form_arquero.validate_on_submit():
logged_user = get_logged_user_data()
# el usuario tiene que estar relacionado al arquero en cuestion
arquero = Arquero.query.filter(
Arquero.id == logged_user.id_arquero).first()
arquero.nombre = form_arquero.nombre.data
arquero.apellido = form_arquero.apellido.data
arquero.email = form_arquero.email.data
arquero.fecha_ingreso = form_arquero.fecha_ingreso.data
arquero.fecha_nacimiento = form_arquero.fecha_nacimiento.data
arquero.dni = form_arquero.dni.data
arquero.telefono = form_arquero.telefono.data
arquero.celular = form_arquero.celular.data
arquero.direccion = form_arquero.direccion.data
arquero.localidad = form_arquero.localidad.data
arquero.codigo_postal = form_arquero.codigo_postal.data
arquero.apodo_eda = form_arquero.apodo_eda.data
arquero.latitud = form_arquero.latitud.data
arquero.longitud = form_arquero.longitud.data
if form_arquero.dominancia_ojo.data:
arquero.id_dominancia_ojo = form_arquero.dominancia_ojo.data.id
if form_arquero.dominancia_mano.data:
arquero.id_dominancia_mano = form_arquero.dominancia_mano.data.id
if 'foto_archivo' in request.files:
filename = None
foto_stream = request.files['foto_archivo']
extension = foto_stream.filename.rsplit('.', 1)[1]
extension = extension.lower()
while True:
filename = '%s.%s' % (random_text(), extension)
if not os.path.exists(
os.path.join(self.upload_folder, filename)):
break
foto_stream.save(os.path.join(self.upload_folder, filename))
arquero.foto = filename
self.db.session.add(arquero)
self.db.session.commit()
return redirect(url_for('auth.logout'))
else:
return render_template('change_my_data.html', form=form_arquero)
def is_admin():
''' Se fija si el usuario en cuestion es administrador.
Esto se lo usa para poder renderar el HTML correpondiente solo
cuando es admin del sistema.
'''
logged_user = get_logged_user_data()
if not logged_user:
return False
if logged_user.es_administrador:
return True
return False
def is_admin():
''' Se fija si el usuario en cuestion es administrador.
Esto se lo usa para poder renderar el HTML correpondiente solo
cuando es admin del sistema.
'''
logged_user = get_logged_user_data()
if not logged_user:
return False
if logged_user.es_administrador:
return True
return False
def post(self):
''' Se encarga de crear el usuario siempre y cuando el hash de la envitacion
siga siendo valido..
'''
# primero me fijo que la invitacion exista y que la misma sea valida
form_arquero = ArqueroForm(Arquero)
if form_arquero.validate_on_submit():
logged_user = get_logged_user_data()
# el usuario tiene que estar relacionado al arquero en cuestion
arquero = Arquero.query.filter(Arquero.id == logged_user.id_arquero).first()
arquero.nombre = form_arquero.nombre.data
arquero.apellido = form_arquero.apellido.data
arquero.email = form_arquero.email.data
arquero.fecha_ingreso = form_arquero.fecha_ingreso.data
arquero.fecha_nacimiento = form_arquero.fecha_nacimiento.data
arquero.dni = form_arquero.dni.data
arquero.telefono = form_arquero.telefono.data
arquero.celular = form_arquero.celular.data
arquero.direccion = form_arquero.direccion.data
arquero.localidad = form_arquero.localidad.data
arquero.codigo_postal = form_arquero.codigo_postal.data
arquero.apodo_eda = form_arquero.apodo_eda.data
arquero.latitud = form_arquero.latitud.data
arquero.longitud = form_arquero.longitud.data
if form_arquero.dominancia_ojo.data:
arquero.id_dominancia_ojo = form_arquero.dominancia_ojo.data.id
if form_arquero.dominancia_mano.data:
arquero.id_dominancia_mano = form_arquero.dominancia_mano.data.id
if 'foto_archivo' in request.files:
filename = None
foto_stream = request.files['foto_archivo']
extension = foto_stream.filename.rsplit('.', 1)[1]
extension = extension.lower()
while True:
filename = '%s.%s' % (random_text(), extension)
if not os.path.exists(os.path.join(self.upload_folder, filename)):
break
foto_stream.save(os.path.join(self.upload_folder, filename))
arquero.foto = filename
self.db.session.add(arquero)
self.db.session.commit()
return redirect(url_for('auth.logout'))
else:
return render_template('change_my_data.html',
form=form_arquero)
def has_permission(required_permission):
''' Se fija si el usuario tiene los permisos necesarios para poder
renderar el html correspondiente.
Esto generalmente va a ir dentro de un IF.
:param str required_permission: el nombre del permiso que tiene que tener
el usuario para que se renderee esa opcion
'''
logged_user = get_logged_user_data()
if not logged_user:
return False
if logged_user.es_administrador:
return True
if required_permission in logged_user.permisos:
return True
return False
def has_permission(required_permission):
''' Se fija si el usuario tiene los permisos necesarios para poder
renderar el html correspondiente.
Esto generalmente va a ir dentro de un IF.
:param str required_permission: el nombre del permiso que tiene que tener
el usuario para que se renderee esa opcion
'''
logged_user = get_logged_user_data()
if not logged_user:
return False
if logged_user.es_administrador:
return True
if required_permission in logged_user.permisos:
return True
return False
def get(self):
''' Se encarga de obtener todos los valores que hay en
la base de datos teniendo en cuenta que:
- la informacion se devuelve de forma paginada asique
de request llega un limit y offset
- la informacion puede estar ordenada por alguna columna
espeficiada en el request. Si es ascendenete o descendente
tambien esta indicado en el request.
- Pueden existir diferentes filtros para la informacion.
Existe un parametro que es para un caso especial:
fkInformation:
en este caso se quiere obtener toda la informacion de la
tabla teniendo en cuenta que se lo va a usar para mostrar
el valor que es referenciado de otra tabla. Por lo tanto,
lo que se quiere en la respuesta son dos valores:
- id: el id del objecto en cuestion.
- value: el str del modelo en cuestion.
Los filtros tienen que tener el siguiente formato:
::
f-0=tableName;columnName;operator;value
donde:
tableName:
es el nombre de la tabla por la que se quiere filtrar
operator:
es el operador por el que se quiere filtrar. Este viene dado
en formato html, y se lo tiene que traducir al operador
correspondiente. Por ejemplo: si el valor es eq entonces
en la query se lo tiene que poner como "="
value:
es el valor por el que se quiere filtrar la informacion.
'''
query = self.model_class.query
joined_tables = []
if 'join' in request.args:
# tengo que decirle antes de mano el tema del join
# porque si despues le especifico las columnas no me deja
# hacerlo
join = request.args['join']
query = query.join(JAVASCRIPT_MODEL_MAPPER[join])
joined_tables.append(JAVASCRIPT_MODEL_MAPPER[join])
# ahora tengo que hacer lo mismo pero teniendo en cuenta si hay
# algun filro que no es por la tabla por la que estoy filtrando.
filters_data = request.args.getlist('filters[]')
for filter_data in filters_data:
table_name, column_name, operator, value = filter_data.split('|')
filter_model = JAVASCRIPT_MODEL_MAPPER[table_name]
if not (filter_model is
self.model_class) and not (filter_model in joined_tables):
query = query.join(filter_model)
joined_tables.append(filter_model)
column = self._get_attribute(column_name, table_name=table_name)
if operator == 'eq':
query = query.filter(column == value)
elif operator == 'lt':
query = query.filter(column < value)
elif operator == 'let':
query = query.filter(column <= value)
elif operator == 'gt':
query = query.filter(column > value)
elif operator == 'get':
query = query.filter(column >= value)
elif operator == 'in':
query = query.filter(column.in_(value.split(',')))
elif operator == 'neq':
query = query.filter(column != value)
elif operator == 'not_null':
query = query.filter(column.isnot(None))
else:
raise Exception('Todavia me falta manejar este caso')
sqlalchemy_columns = []
if 'columns[]' in request.args:
columns = request.args.getlist('columns[]')
for column_name in columns:
aggregation_name = None
if '(' in column_name:
aggregation_name = column_name[:column_name.index('(')]
aggregation_name = aggregation_name.lower()
column_name = column_name[column_name.index('(') +
1:column_name.index(')')]
column = self._get_attribute(column_name)
if aggregation_name:
if aggregation_name == 'month':
sqlalchemy_columns.extend([
func.extract('year', column),
func.extract('month', column)
])
continue
else:
column = getattr(func, aggregation_name)(column)
sqlalchemy_columns.append(column)
query = query.with_entities(*sqlalchemy_columns)
if 'orderBy' in request.args:
order_by = request.args['orderBy']
if order_by:
column = self._get_attribute(order_by)
order_direction = request.args.get('orderDirection', 'ASC')
if order_direction == 'DESC':
query = query.order_by(column.desc())
else:
query = query.order_by(column)
if 'groupBy' in request.args:
group_by = request.args['groupBy']
if group_by:
aggregation_name = None
if '(' in group_by:
aggregation_name = group_by[:group_by.index('(')]
aggregation_name = aggregation_name.lower()
group_by = group_by[group_by.index('(') +
1:group_by.index(')')]
column = self._get_attribute(group_by)
if aggregation_name:
if aggregation_name == 'month':
query = query.group_by(func.extract('year', column))
query = query.group_by(func.extract('month', column))
else:
raise Exception('Todavia no implemente este caso')
else:
query = query.group_by(column)
# ahora solo tengo que filtrar por el usuario correspondiente.
# en caso de que el usuario logueado no sea entrenador o
# administrador entonces solo va a poder ver su informacion
logged_user = get_logged_user_data()
if not logged_user.es_administrador:
# en este caso, me tengo que fijar de ver si el usuario
# puede ver todos los valores que corresponden a todos
# los otros arqueros. Pero si es otro modelo, tengo
# que ver que el mismo tenga los permisos correspondientes
if isinstance(self.model_class, Arquero):
# si estoy viendo la lista de arqueros, entonces
# solo la comision puede ver a todos ellos. Sino,
# solo me puedo ver a mi mismo
if not logged_user.permisos:
query = query.filter(Arquero.id == logged_user.id_arquero)
elif isinstance(self.model_class, Usuario):
# Lo mismo que cuando estan viendo los arqueros
if not logged_user.permisos:
query = query.filter(Usuario.id == logged_user.id)
#elif isinstance(self.model_class, (Torneo, EntrenamientoRealizado, ArcoRecurvado, Flechas)):
# # solo los entrenadores pueden ver la informacion de otras personas.
# self.add_filter_for_permission(self.model_class, 'es_entrenador')
#elif isinstance(self.model_class, (Pago, Gastos)):
# # solo los de tesoreria pueden ver estas opciones
# self.add_filter_for_permission(self.model_class, ['es_de_tesoreria', 'es_entreneador'])
#elif isinstance(self.model_class, None):
# raise Exception('TODO')
if hasattr(self.model_class, 'id_usuario'):
if not (logged_user.es_administrador or logged_user.permisos):
# TODO se deberia ver que tenga los permisos correspondientes para
# poder ejecutar la view en cuestion
query = query.filter(
getattr(self.model_class, 'id_usuario') == logged_user.id)
elif hasattr(self.model_class, 'id_arquero'):
logged_user = get_logged_user_data()
if not (logged_user.es_administrador or logged_user.permisos):
# TODO ver como manejo los permisos cuando alguien
# pertence a la comisicion
query = query.filter(
getattr(self.model_class, 'id_arquero') ==
logged_user.id_arquero)
elif isinstance(self.model_class, Arquero):
# si estoy viendo los arqueros, entonces una persona normal
# solo se puede ver a si solo. No tengo que hacer esto para
# el caso de los usuarios porque cae en el if anterior
logged_user = get_logged_user_data()
if not (logged_user.es_administrador or logged_user.permisos):
# TODO ver como manejo los permisos cuando alguien
# pertence a la comisicion
query = query.filter(Arquero.id == logged_user.id_arquero)
if (not 'fkInformation' in request.args) and (not 'columns[]'
in request.args):
# esto lo tengo que poner antes del limit y offset porque sino
# el count va a tener en cuenta esas cosas
filter_count = query.count()
if 'limit' in request.args:
limit = int(request.args['limit'])
query = query.limit(limit)
if 'offset' in request.args:
offset = int(request.args['offset'])
query = query.offset(offset)
if 'fkInformation' in request.args:
total_count = 0
filter_count = 0
if hasattr(self.model_class, 'to_fk_information'):
res = [d.to_fk_information() for d in query.all()]
else:
res = [dict(id=d.id, value=unicode(d)) for d in query.all()]
elif 'columns[]' in request.args:
total_count = 0
filter_count = 0
res = [d for d in query.values(*sqlalchemy_columns)]
# ahora me tengo que asegurar que todos los valores que uso
# sean serializables
tmp_res = []
for values in res:
tmp_values = []
for column_value in values:
if isinstance(column_value, (date, datetime)):
column_value = column_value.strftime('%d/%m/%Y')
tmp_values.append(column_value)
tmp_res.append(tmp_values)
res = tmp_res
else:
res = [d.to_json() for d in query.all()]
# ahora me tengo que fijar cuantos existen en la base de datos
# en total y cuantos existen cuando se aplican los filtros
total_count = self.model_class.query.count()
return jsonify(values=res,
totalCount=total_count,
filterCount=filter_count)
def get(self):
logged_user = get_logged_user_data()
arquero = Arquero.query.filter(Arquero.id == logged_user.id_arquero).first()
return render_template('change_my_data.html',
form=ArqueroForm(Arquero, arquero.id, obj=arquero))