class Arco(BaseModel):
''' Representa toda la informacion del arco que un usuario puede usar.
:param str nombre: un nombre que le dio el usuario al arco para
poder identificar el mismo.
:param str tipo_de_arco: indica si el arco es compuesto o recurvado.
:param str comentario: algun comentario que quiera agregar el usuario
sobre el arco.
:param str modelo_barra_larga_estabilizacion: es el nombre del modelo
de la barra principal de
estabilizacion.
:param int largo_barra_larga_estabilizacion: es el largo en pulgadas
de la barra.
:param int peso_adicional_barra_larga: el peso, en grames, que se le
agrego a la barra.
.. todo:: falta agregar los campos para ver si la barra tiene
dumpers o no.
'''
__mapper_args__ = {'polymorphic_on': 'tipo_arco'}
id = db.Column(db.Integer, primary_key=True)
id_usuario = db.Column(db.Integer, db.ForeignKey('usuario.id'))
nombre = db.Column(db.String(1024), nullable=False)
comentario = db.Column(db.Text)
foto_path = db.Column(db.Text, nullable=True)
tipo_arco = db.Column(db.String(255), nullable=False)
draw = db.Column(db.Float)
id_marca_barra_larga_estabilizacion = db.Column(
db.Integer, db.ForeignKey('marca_estabilizacion.id'))
modelo_barra_larga_estabilizacion = db.Column(db.String(1024))
largo_barra_larga_estabilizacion = db.Column(db.Integer)
peso_adicional_barra_larga = db.Column(db.Integer)
id_marca_barra_lateral_estabilizacion = db.Column(
db.Integer, db.ForeignKey('marca_estabilizacion.id'))
modelo_barra_lateral_estabilizacion = db.Column(db.String(1024))
largo_barra_lateral_estabilizacion = db.Column(db.Integer)
peso_adicional_barra_lateral = db.Column(db.Integer)
id_marca_extender_estabilizacion = db.Column(
db.Integer, db.ForeignKey('marca_estabilizacion.id'))
modelo_extender_estabilizacion = db.Column(db.String(1024))
largo_extender_estabilizacion = db.Column(db.Integer)
modelo_vbar_estabilizacion = db.Column(db.String(1024))
vbar_angulo_apertura = db.Column(db.Integer)
vbar_angulo_inclinacion = db.Column(db.Integer)
modelo_rest = db.Column(db.String(1024))
def __str__(self):
return '%s' % self.nombre
class Flechas(BaseModel):
''' Tiene toda la informacion de las flechas que puede llegar a usar
el arquero en cuestion.
:param int id: un identificador autogenerado.
:param int id_usuario: el identificador del usuario a quien le pertence toda
la informacion de las flechas.
:param str comentario: un comentario sobre las flechas que uno esta usando
Por ejemplo: "las corte 2mm de atras, etc.."
:param int id_tipo_uso: identifica si las flechas se las usa solo para indoor,
o solo para outdoor o para ambas.
:param int id_marca_flechas: el identificador de la marca de las flechas (easton,
cartel, etc..)
:param int id_modelo_flechas: el identificador del modelo de flechas (carbon one,
jazz, etc...)
:param int calibre_flechas: indica el calibre de la flecha. Para las jazz, y
las platinum el mismo va a ser algo como 1916, pero
para las flechas de carbono va a ser algo como 600
:param int punta: informacion de la punta. Para flechas de outdoor indica el peso
en grames de las mismas.
:param float largo: el largo de las flechas que usa.
:param str info_nock: toda la informacion del nock (marca, modelo, tamaño)
:param str info_timones: toda la informacion sobre los timones que se estan usando
(color, largo, marca y modelo, etc..)
'''
id = db.Column(db.Integer, primary_key=True, nullable=False)
id_usuario = db.Column(db.Integer,
db.ForeignKey('usuario.id', ondelete='CASCADE'),
nullable=False)
comentario = db.Column(db.Text)
id_tipo_uso = db.Column(db.Integer,
db.ForeignKey('tipo_uso_flechas.id'),
nullable=False)
id_marca_flechas = db.Column(db.Integer,
db.ForeignKey('marca_flechas.id'),
nullable=False)
id_modelo_flechas = db.Column(db.Integer,
db.ForeignKey('modelo_flechas.id'),
nullable=False)
calibre_flechas = db.Column(db.Integer)
punta = db.Column(db.Integer)
largo = db.Column(db.Float)
info_nock = db.Column(db.String(1024))
info_timones = db.Column(db.String(1024))
class Arquero(BaseModel):
''' Representa toda la informacion de todos los arqueros que hubo
en la escuela.
Se considera a una person un arquero si fue al menos a una clase.
:param str email: el email del usuario. El mismo es usado
para mandarle mails con respecto a cambios
en el sistema o si el usuario se olvido la
clave.
:param str nombre: el nombre/s de la persona fisica que es
representado por este usuario,
:param str apellido: el/los apellido/s de la persona fisica que es
representado por este usuario.
'''
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(1024), nullable=False)
apellido = db.Column(db.String(1024), nullable=False)
email = db.Column(db.String(250), nullable=True, unique=True)
codigo = db.Column(db.String(10), nullable=False, unique=True)
# estos datos son pedidos usados por la data de la EDA
fecha_ingreso = db.Column(db.Date)
fecha_abandono = db.Column(db.Date)
fecha_nacimiento = db.Column(db.Date)
telefono = db.Column(db.String(1024))
celular = db.Column(db.String(1024))
direccion = db.Column(db.String(1024))
localidad = db.Column(db.String(1024))
dni = db.Column(db.String(20))
apodo_eda = db.Column(db.String(1024))
id_dominancia_ojo = db.Column(db.Integer,
db.ForeignKey('dominancia_ojo.id'),
nullable=True)
id_dominancia_mano = db.Column(db.Integer,
db.ForeignKey('dominancia_mano.id'),
nullable=True)
codigo_postal = db.Column(db.String(20))
foto = db.Column(db.String(1024))
latitud = db.Column(db.Float)
longitud = db.Column(db.Float)
usuario = db.relationship('Usuario', backref='arquero')
def __str__(self):
return '%s %s' % (self.apellido, self.nombre)
def to_fk_information(self):
return dict(imagePath='user_images/' +
self.foto if self.foto else None,
id=self.id,
value=unicode(self))
class Torneo(BaseModel):
''' Tiene toda la informacion sobre el tipo de resultado.
Es importante tener en cuenta que esto se lo usa tanto para
los torneos reales como para las practicas de torneos.
:param int id: un numero autoincrementado.
:param date cuando: la fecha de cuando fue el torneo en cuestion.
:param int id_usuario: el id del usuario que va a cargar la informacion
sobre como le fue en el torneo.
:param int id_lugar: el identificador del lugar en donde fue el
torneo.
:param str tipo_de_torneo: identifica que tipo de torneo se esta haciendo.
:param int puntaje_final_torneo: es la suma del puntaje de las 4 o 2
series del torneo.
:param boolean fue_practica: si es True, entonces esto no fue un torneo
en si, sino que fue una practica.
:param str comentario: el comentario que quiere poner el usuario en cuestion.
:param int posicion_classificacion: la posicion que termino el tirador
teniendo en cuenta las X rondas del torneo.
Esto no es para la posicion dentro si se gano
medalla
:param int posicion_eliminatorias: la posicion que se tiene en las eliminatorias.
Basicamente esto es para ver si se termino 1,
2 o 3°
'''
id = db.Column(db.Integer, primary_key=True)
cuando = db.Column(db.Date, nullable=False)
id_usuario = db.Column(db.Integer, db.ForeignKey('usuario.id', ondelete='CASCADE'), nullable=False)
id_tipo_de_torneo = db.Column(db.Integer, db.ForeignKey('tipo_torneo.id'), nullable=False)
id_lugar = db.Column(db.Integer, db.ForeignKey('lugar.id', ondelete='SET NULL'))
id_arco = db.Column(db.Integer, db.ForeignKey('arco.id', ondelete='SET NULL'))
comentario = db.Column(db.Text)
puntaje_final_torneo = db.Column(db.Integer)
fue_practica = db.Column(db.Boolean, nullable=False)
posicion_classificacion = db.Column(db.Integer)
posicion_eliminatoria = db.Column(db.Integer)
class EntrenamientoFlechas(BaseModel):
''' Tiene toda la informacion detallada sobre las felchas que se tiraron
en un dia especifico.
'''
id = db.Column(db.Integer, primary_key=True)
id_entrenamiento_realizado = db.Column(db.Integer,
db.ForeignKey(
'entrenamiento_realizado.id',
ondelete='CASCADE'),
nullable=False)
hora_inicio = db.Column(db.Time)
cantidad_de_flechas = db.Column(db.Integer)
distancia = db.Column(db.Integer)
id_arco = db.Column(db.Integer, db.ForeignKey('arco.id'))
id_lugar = db.Column(db.Integer, db.ForeignKey('lugar.id'))
class Serie(BaseModel):
''' Tiene toda la informacion para una de las series del
torneo.
:param int id: un valor unico autoincrementado.
:param boolean fue_de_practica: si es True, entonces esta serie
fue una de las series de pracitca
antes de empezar las series que se
puntean
:param int puntaje_flecha_X: el puntaje de la flecha X. El mismo tiene
que ir desde el puntaje mas alto al puntaje
mas bajo. Es decir, puntaje_flecha_1 tiene
que ser el mas alto, y puntaje_flecha_6 el
mas bajo. En caso de que una flecha haya sido
mala, entonces se la pone como 0.
:param int puntaje_final: el puntaje de las 6 flechas.
'''
id = db.Column(db.Integer, primary_key=True)
id_ronda = db.Column(db.Integer, db.ForeignKey('ronda.id', ondelete='CASCADE'), nullable=False)
fue_de_practica = db.Column(db.Boolean)
puntaje_flecha_1 = db.Column(db.Integer)
puntaje_flecha_2 = db.Column(db.Integer)
puntaje_flecha_3 = db.Column(db.Integer)
puntaje_flecha_4 = db.Column(db.Integer)
puntaje_flecha_5 = db.Column(db.Integer)
puntaje_flecha_6 = db.Column(db.Integer)
puntaje_total = db.Column(db.Integer)
class EntrenamientoRealizado(BaseModel):
''' Tiene toda la informacion sobre el entrenamiento que hizo uno de los
arqueros
'''
id = db.Column(db.Integer, primary_key=True)
id_usuario = db.Column(db.Integer,
db.ForeignKey('usuario.id', ondelete='CASCADE'),
nullable=False)
cuando = db.Column(db.Date, nullable=False)
class Asistencia(BaseModel):
''' Se encarga de manejar el tema de que personas fueron a que turno.
Esto es para manejar un registro de las personas que fueron por cada
turno a la escuela.
:param int id: un identificador unico autogenerado
:param int id_turno: el turno al cual el arquero asistio
:param int id_arquero: el arquero que fue a la clase.
'''
id = db.Column(db.Integer, primary_key=True)
id_turno = db.Column(db.Integer, db.ForeignKey('turno.id'), nullable=False)
id_arquero = db.Column(db.Integer, db.ForeignKey('arquero.id'), nullable=False)
cuando = db.Column(db.Date, nullable=False)
__table_args__ = (
db.UniqueConstraint('id_turno', 'id_arquero', 'cuando', name='asistencia_turno_arquero_cuando'),
)
class HistoriaEstadoArquero(BaseModel):
''' Representa toda la historia del estado de actividad del arquero.
Como el arquero puede ir cambiando entre dos estados (Pasivo y Activo)
entonces tenemos que ir guardando el historial.
Un par de cosas a tener en cuenta sobre los valores:
- si hasta es None, entonces tenemos que este es el ultimo estado
de actividad del arquero porque significa hasta la fecha
actual.
- El hasta es el ultimo mes en el que estuvo en ese estado.
Supongamos que en enero yo estuve pasivo, y en febrero ya pase a
activo de nuevo. Entonces el hasta va a ser la fecha de enero (que
va a ser la misma que la fecha de "desde")
:param int id: un identificador unico autogenerado
:param int id_arquero: el identificador del arquero para quien
se encuentra en este estado.
:param int id_estado: el identificador del estado en el que se
encuentra el arquero
:param date desde: la fecha desde la cual se encuentra en ese
estado. Como los estados son por mes, entonces
esto siempre va a ser el primer dia de cada mes.
:param date hasta: la fecha hasta la cual se encuentraba en ese
estado. Tambien es el primer dia de cada mes.
'''
id = db.Column(db.Integer, primary_key=True)
id_arquero = db.Column(db.Integer, db.ForeignKey('arquero.id'), nullable=False)
id_estado_arquero = db.Column(db.Integer, db.ForeignKey('estado_arquero.id'), nullable=False)
desde = db.Column(db.Date, nullable=False)
hasta = db.Column(db.Date)
__table_args__ = (
db.UniqueConstraint('id_arquero', 'desde', name='historia_estado_arquero_arquero_desde'),
)
class Usuario(BaseModel):
''' Representa toda la informacion de un usuario que se
puede loguear a la aplicacion.
:param str password: el password del usuario. El mismo esta
encryptado usando Bcrypt.
:param str nombre: el nombre/s de la persona fisica que es
representado por este usuario,
:param str apellido: el/los apellido/s de la persona fisica que es
representado por este usuario.
:param bool es_administrador: si es True, entonces puede ver la informacion
de los otros usuarios y ademas puede cargar
ciertas cosas que el entrenador no puede.
:param str foto: el path en donde se encuentra la foto del arquero.
:param float latitud: la latitud de donde vive el arquero en cuestion.
:param float longitud: la longitud de donde vive el arquero.
:param str dominancia_ojo: indica si el ojo con el que apunta el arquero
es distro o zurdo
:param str dominancia_mano: indica si el arquero generalmente es diestro
o zurdo o ambi-diestro para hacer las cosas
de la vida (escribir, comer, etc...)
'''
id = db.Column(db.Integer, primary_key=True)
id_arquero = db.Column(db.Integer,
db.ForeignKey('arquero.id'),
nullable=False)
password = db.Column(db.String(1024), nullable=False)
es_administrador = db.Column(db.Boolean, nullable=False, default=False)
def to_json(self):
res = super(Usuario, self).to_json()
res['arquero'] = self.arquero.to_json()
del res['password']
del res['es_administrador']
return res
def __str__(self):
return unicode(self.arquero)
return u'%s %s' % (self.arquero.apellido, self.arquero.nombre)
def to_fk_information(self):
return self.arquero.to_fk_information()
class Turno(BaseModel):
''' Tiene toda la informacion de los diferentes lugares en donde
se dan clases.
Estos son los horarios oficiales. Es sabido que el arquero puede
llegar a ir a entrenar cuando quiera, pero aca solo se guarda
la informacion de cuando se dan clases
'''
id = db.Column(db.Integer, primary_key=True)
id_lugar = db.Column(db.Integer, db.ForeignKey('lugar.id'), nullable=False)
id_dia_semana = db.Column(db.Integer,
db.ForeignKey('dia_semana.id'),
nullable=False)
horario_inicio = db.Column(db.Time, nullable=False)
horario_fin = db.Column(db.Time, nullable=False)
def __str__(self):
return '%s: %s - %s' % (self.lugar, self.horario_inicio,
self.horario_fin)
class PermisoUsuario(BaseModel):
''' Tiene toda la informacion de como es que se relacionan los permisos
con los usuarios del sistema correspondiente.
:param int usuario: el identificador del usuario a quien se le va a
asignar el permiso correspondiente.
:param int permiso: el identificador del permiso que se le esta
asignando al usuario.
'''
__table_args__ = (UniqueConstraint('id_usuario',
'id_permiso',
name='usuario_permiso_unique'), )
id = db.Column(db.Integer, primary_key=True)
id_usuario = db.Column(db.Integer,
db.ForeignKey('usuario.id', ondelete='CASCADE'),
nullable=False)
id_permiso = db.Column(db.Integer,
db.ForeignKey('permiso.id', ondelete='CASCADE'),
nullable=False)
class FechaEspecial(BaseModel):
''' Tiene toda la informacion de un tipo de fecha que es especial.
Por ejemplo:
- tiene la informacion de cuando es feriado
- cuando son los diferentes tipos de torneos
- cuando son las clinicas
'''
id = db.Column(db.Integer, primary_key=True)
cuando = db.Column(db.Date, nullable=False)
id_tipo_dia_especial = db.Column(db.Integer,
db.ForeignKey('tipo_dia_especial.id', ondelete='CASCADE'),
nullable=False)
class ArcoRecurvado(Arco):
''' En este caso se guarda toda la informacion sobre el arco recurvado
que el usuario esta usando.
'''
__mapper_args__ = {'polymorphic_identity': 'recurvado'}
id = db.Column(db.Integer, db.ForeignKey('arco.id'), primary_key=True)
id_marca_riser = db.Column(db.Integer, db.ForeignKey('marca_riser.id'))
modelo_riser = db.Column(db.String(1024))
id_largo_riser = db.Column(db.Integer, db.ForeignKey('largo_riser.id'))
id_tipo_encastre = db.Column(db.Integer, db.ForeignKey('tipo_encastre.id'))
usa_barras_cortas = db.Column(db.Boolean, nullable=False, default=False)
id_marca_palas = db.Column(db.Integer, db.ForeignKey('marca_palas.id'))
modelo_palas = db.Column(db.String(1024))
libraje_palas = db.Column(db.Integer)
libraje_real = db.Column(db.Integer)
id_largo_palas = db.Column(db.Integer, db.ForeignKey('largo_palas.id'))
usa_honguitos = db.Column(db.Boolean, nullable=False, default=False)
tiller = db.Column(db.Float)
brace = db.Column(db.Float)
altura_nocking_point = db.Column(db.Float)
modelo_clicker = db.Column(db.String(1024))
id_marca_mira = db.Column(db.Integer, db.ForeignKey('marca_mira.id'))
modelo_mira = db.Column(db.String(1024))
usa_peewees = db.Column(db.Boolean, nullable=False, default=False)
modelo_cushion_plunger = db.Column(db.String(1024))
id_tipo_hilo_cuerda = db.Column(db.Integer,
db.ForeignKey('tipo_hilo_cuerda.id'))
cantidad_hilos_cuerda = db.Column(db.Integer)
largo_cuerda = db.Column(db.Integer)
cantidad_vueltas_cuerda = db.Column(db.Integer)
class Invitacion(BaseModel):
''' Como los arqueros normalmente solo se pueden registrar mediante una
invitacion, esto registra a todas las personas a quienes se les envio
una invitacion.
:param int id: un identificador autogenerado.
:param int id_arquero: el identificador del arquero a quien se le
envio el email para que se cree una cuenta.
:param str codigo: un codigo de la invitacion. Esto es un campo interno
para asegurarse de quienes se le hayan enviado una
invitacion puedan crear su usuario.
:param boolean usada: si es True, entonces la misma ya fue usada y no
se la puede usar para crear a otro usuario.
'''
id = db.Column(db.Integer, primary_key=True)
id_arquero = db.Column(db.Integer, db.ForeignKey('arquero.id'), nullable=False)
codigo = db.Column(db.String(10), nullable=False, unique=True)
usada = db.Column(db.Boolean, nullable=False, default=False)
class Gasto(BaseModel):
''' Tiene toda la informacion correspondiente a un gasto de la escuela.
Los gastos de la escuela pueden ser de varios tipos:
- sueldos
- gasto en alquileres
- compra de equipo
- otras cosas
:param int id: el identificador del pago.
:param date cuando: cuando es que el gasto fue hecho. No cuando
el gasto fue registrado en el sistma, sino
cuando fue hecho el mismo.
:param date mes_correspondiente: a que mes corresponde el gasto.
Este campo es necesario ademas,
del :attr:`cuando`, para tener
en cuenta los casos en donde uno
paga mas de un mes atrasado.
:param float importe: el importe que pago el usuario en cuestion.
:param int razon_gasto: el identificador de la razon del pago hecha
por el usuario.
:param str comentario: algun comentario sobre el pago que realizo el
usuario
'''
id = db.Column(db.Integer, primary_key=True)
id_razon_gasto = db.Column(db.Integer, db.ForeignKey('razon_gasto.id'), nullable=False)
cuando = db.Column(db.Date, nullable=False)
mes_correspondiente = db.Column(db.Date, nullable=False)
importe = db.Column(db.Float, nullable=False)
comentario = db.Column(db.Text)
class Ronda(BaseModel):
''' Tiene toda la informacion de una ronda del torneo.
:param int id: un valor unico autoincrementado
:param int id_torneo: el identificador del torneo a donde pertence
la ronda en cuestion.
:param int puntaje: el puntaje que se hizo en esta ronda.
:param int distancia: la distancia a la que se tiro en este
torneo.
:param str foto: en caso de que no se quiera cargar toda la
inforamcion de las series, tiene la foto de
la planilla de resultado que se le entrego
a los jueces
'''
id = db.Column(db.Integer, primary_key=True)
id_torneo = db.Column(db.Integer, db.ForeignKey('torneo.id', ondelete='CASCADE'), nullable=False)
puntaje = db.Column(db.Integer)
distancia = db.Column(db.Integer)
foto_path = db.Column(db.Text)
class Pago(BaseModel):
''' Tiene toda la informacion correspondiente a un pago.
A diferencia de otros modelos, la informacion de este puede
ser ingresada por una tercer persona. Por ejemplo, alguien de
la comision directiva puede agregar un pago a nombre de X
persona.
:param int id: el identificador del pago.
:param date cuando: cuando es que el pago fue hecho. No cuando
el pago fue registrado en el sistma, sino
cuando fue hecho el mismo.
:param date mes_correspondiente: a que mes corresponde el pago.
Este campo es necesario ademas,
del :attr:`cuando`, para tener
en cuenta los casos en donde uno
paga mas de un mes atrasado.
:param float importe: el importe que pago el usuario en cuestion.
:param int razon_pago: el identificador de la razon del pago hecha
por el usuario.
:param str foto_comprobante: el path al documento en donde el usuario
pasa la informacion del comprobante de pago
(puede ser un PDF, una foto, etc...)
:param str comentario: algun comentario sobre el pago que realizo el
usuario
:param int cargado_por: el usuario que cargo el pago. Si uno mismo
esta cargando un pago a su nombre entonces
el valor de este campo es el mismo que usuario.
Pero si la Comision esta cargando un pago
a nombre de otro, este es el nombre de la
persona de la comision, y el :attr:`usuario`
es la persona que hizo el pago.
:param int id_arquero: el identificador del arquero a quien le
corresponde este pago.
'''
id = db.Column(db.Integer, primary_key=True)
id_razon_pago = db.Column(db.Integer,
db.ForeignKey('razon_pago.id'),
nullable=False)
id_arquero = db.Column(db.Integer,
db.ForeignKey('arquero.id'),
nullable=False)
id_cargado_por = db.Column(db.Integer,
db.ForeignKey('usuario.id'),
nullable=False)
cuando = db.Column(db.Date, nullable=False)
mes_correspondiente = db.Column(db.Date, nullable=False)
importe = db.Column(db.Float, nullable=False)
comprobante_path = db.Column(db.Text)
comentario = db.Column(db.Text)