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 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 BaseConstModel(BaseModel):
''' Clase base para todos los modelos que son de tablas constantes.
Como todos ellos comparten el mismo schema, entonces la idea es
hacer una clase base para no tener que estar difiniendo el schema
todo el tiempo.
'''
__abstract__ = True
__mapper_args__ = {'always_refresh': True}
id = db.Column(db.Integer, primary_key=True)
value = db.Column(db.Text, unique=True)
show_order = db.Column(db.Integer, unique=True)
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 Permiso(BaseModel):
''' Tiene los diferentes permisos que pueden llegar a ser
asignados a los usuarios para que los mismos ejecuten diferentes
opciones en el sistema.
:param int id: un identificador del permiso autogenerador
:param str value: un texto que indica que cosas puede hacer el
usuario que tiene asignado este permiso.
'''
id = db.Column(db.Integer, primary_key=True)
value = db.Column(db.Text, unique=True)
def __str__(self):
return self.value
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 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 TipoDiaEspecial(BaseModel):
''' Tiene toda la informacion para un los tipos de dias especiales de
entrenamiento.
Por ejemplo:
- los dias que hay un torneo outdoor
- los dias que hay un torneo indoor
- los feriados nacionales
- las clinicas de entrenamiento
'''
__tablename__ = 'tipo_dia_especial'
id = db.Column(db.Integer, primary_key=True)
value = db.Column(db.Text, nullable=False)
color = db.Column(db.Text, nullable=False)
def __str__(self):
return self.value
class Lugar(BaseModel):
''' Representa uno de los lugares en donde el arquero
entrena.
Tambien se lo puede llegar a usar para marcar los lugares
en donde algun usuario fue a algun torneo.
:param str nombre: un nombre que identifica el lugar de los
otros lugares. Por ejemplo: Club Maldonado.
:param float latitud: la latitud de donde queda el lugar.
:param float longitud: la longitud de donde queda el lugar
:param boolean es_de_entrenamiento: si es True, entonces este es un
lugar donde los arqueros pueden
entrenar. Sino es un lugar a donde
los arqueros fueron a tirar por
una vez un torneo.
:param boolean es_outdoor: si es True, entonces es un lugar outdoor,
sino es indoor.
'''
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(1024), unique=True, nullable=False)
latitud = db.Column(db.Float, nullable=False)
longitud = db.Column(db.Float, nullable=False)
es_de_entrenamiento = db.Column(db.Boolean, nullable=False, default=True)
es_outdoor = db.Column(db.Boolean, nullable=False)
turno = db.relationship('Turno', backref='lugar')
def __str__(self):
return self.nombre
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 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 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 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 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 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 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 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 TipoTorneo(BaseModel):
''' Tiene toda la informacion de los diferentes tipos de
torneos.
Aunque esto es una clase constante que no cambia, el modelo
es diferente a las otras tablas constantes porque el mismo
tiene mas informacion que es necesaria por la parte de javascript
para poder resolver ciertas cosas.
'''
__tablename__ = 'tipo_torneo'
id = db.Column(db.Integer, primary_key=True)
nombre = db.Column(db.String(256), nullable=False)
tipo = db.Column(db.String(256), nullable=False)
es_escuela = db.Column(db.Boolean, nullable=False)
numero_de_rondas = db.Column(db.Integer, nullable=False)
numero_de_series = db.Column(db.Integer, nullable=False)
numero_de_flechas_por_serie = db.Column(db.Integer, nullable=False)
distancia_ronda_1 = db.Column(db.Integer, nullable=False)
series_de_practica_ronda_1 = db.Column(db.Integer, nullable=False)
distancia_ronda_2 = db.Column(db.Integer, nullable=False)
series_de_practica_ronda_2 = db.Column(db.Integer, nullable=False)
# partir de la 3 ronda, si puede llegar a ser null porque dependiendo
# del tipo de torneo tenemos que no puede haber una tercer ronda
distancia_ronda_3 = db.Column(db.Integer)
series_de_practica_ronda_3 = db.Column(db.Integer)
distancia_ronda_4 = db.Column(db.Integer)
series_de_practica_ronda_4 = db.Column(db.Integer)
def to_fk_information(self):
res = self.to_json()
res['value'] = '%s -- %s' % (self.tipo, self.nombre)
return res
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 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)
