def nueva_competencia(self, dto):
from gestorusuario import GestorUsuario
from gestorlugar import GestorLugar
lista_competencias = GestorBaseDeDatos.get_instance().listar_competencias()
deporte = GestorBaseDeDatos.get_instance().listar_deportes(nombre = dto.deporte)
lista_sedes = []
for DTOLugares in dto.lugares:
lugar = GestorLugar.get_instance().listar_lugar(id_lugar = DTOLugares.id)
sede = Sede(lugar=lugar, disponibilidad=DTOLugares.disponibilidad)
lista_sedes.append(sede)
for competencias in lista_competencias:
if dto.nombre == competencias.nombre:
raise NombreExistente('Ya existe ese nombre de competencia en la base de datos.')
if dto.tipo == 'eliminatoriasimple':
competencia_new = CompetenciaEliminatoriaSimple(nombre=dto.nombre, tipo_puntuacion=dto.tipo_puntuacion,
cantidad_de_sets=dto.cantidad_de_sets, reglamento=dto.reglamento,
estado='Creada', tantos_presentismo=dto.tantos_presentismo,
sedes=lista_sedes, deporte=deporte)
elif dto.tipo == 'eliminatoriadoble':
competencia_new = CompetenciaEliminatoriaDoble(nombre=dto.nombre, tipo_puntuacion=dto.tipo_puntuacion,
cantidad_de_sets=dto.cantidad_de_sets, reglamento=dto.reglamento,
estado='Creada', tantos_presentismo=dto.tantos_presentismo,
sedes=lista_sedes, deporte=deporte)
else:
competencia_new = CompetenciaLiga(nombre=dto.nombre, tipo_puntuacion=dto.tipo_puntuacion,
cantidad_de_sets=dto.cantidad_de_sets, reglamento=dto.reglamento,
estado='Creada', tantos_presentismo=dto.tantos_presentismo,
sedes=lista_sedes,
puntos_por_presentarse=dto.puntos_por_presentarse,
puntos_por_ganar=dto.puntos_por_ganar,
puntos_por_empate=dto.puntos_por_empate, deporte = deporte,
permitir_empate=dto.permitir_empate)
GestorUsuario.get_instance().agregar_competencia(dto.id_usuario, competencia_new)
return 1
def listar_lugar(self, id_usuario = None, id_lugar = None):
if id_lugar is not None:
return GestorBaseDeDatos.get_instance().listar_lugar(id_lugar=id_lugar)
if id_usuario is not None:
lista_dto = []
lista_lugares = GestorBaseDeDatos.get_instance().listar_lugar(id_usuario= id_usuario)
for lugar in lista_lugares:
dto = DTOLugar(lugar.id, lugar.nombre, lugar.descripcion, None)
lista_dto.append(dto)
return lista_dto
def agregar_participante(self, id_competencia, participante):
competencia = GestorBaseDeDatos.get_instance().listar_competencias(id_competencia = id_competencia)
retorno = 1
if competencia.estado in ['En Disputa', 'Finalizada']:
raise FaltaDeDatos('No se puede agregar participante a una competencia a la que ya se le agregaron resultados.')
for parts in competencia.participantes:
if parts.nombre == participante.nombre:
raise NombreExistente('Este participante ya existe en esta competencia.')
if parts.correo_electronico == participante.correo_electronico:
raise NombreExistente('Este correo electronico ya existe en esta competencia.')
if competencia.partidas:
GestorCompetencia.get_instance().eliminar_fixture(id_competencia = competencia.id)
retorno = 2
competencia.participantes.append(participante)
competencia.estado = 'Creada'
GestorBaseDeDatos.get_instance().modificar_competencia()
return retorno
def listar_competencias(self, id_competencia = None, nombre=None, id_usuario = None, deporte = None,
modalidad = None, estado = None):
"""Realiza la correspondiente busqueda de competencias, devuelve una lista de DTOs Competencias"""
from gestorusuario import GestorUsuario
lista_dtos = []
if id_competencia is not None:
competencia = GestorBaseDeDatos.get_instance().listar_competencias(id_competencia=id_competencia)
usuario = GestorUsuario.get_instance().obtener_usuario(competencia.id_usuario)
if competencia.tipo =='eliminatoriasimple' or competencia.tipo =='eliminatoriadoble':
lista_dtos.append(DTOCompetencia(competencia.id, competencia.nombre, competencia.tipo_puntuacion,
competencia.estado, competencia.reglamento, competencia.id_usuario,
usuario.nombre, competencia.tipo, competencia.cantidad_de_sets,
None, None, None, competencia.deporte.nombre, None,
competencia.tantos_presentismo, None))
else:
lista_dtos.append(DTOCompetencia(competencia.id, competencia.nombre, competencia.tipo_puntuacion,
competencia.estado, competencia.reglamento, competencia.id_usuario,
usuario.nombre, competencia.tipo, competencia.cantidad_de_sets,
competencia.puntos_por_presentarse, competencia.puntos_por_ganar,
competencia.puntos_por_empate, competencia.deporte.nombre, None,
competencia.tantos_presentismo, competencia.permitir_empate))
else:
lista_competencias = GestorBaseDeDatos.get_instance().listar_competencias(nombre=nombre,
id_usuario=id_usuario,
deporte=deporte,
modalidad=modalidad,
estado=estado)
for competencia in lista_competencias:
usuario = GestorUsuario.get_instance().obtener_usuario(competencia.id_usuario)
if competencia.tipo == 'eliminatoriasimple' or competencia.tipo == 'eliminatoriadoble':
lista_dtos.append(DTOCompetencia(competencia.id, competencia.nombre, competencia.tipo_puntuacion,
competencia.estado, competencia.reglamento,
competencia.id_usuario, usuario.nombre, competencia.tipo,
competencia.cantidad_de_sets, None, None, None,
competencia.deporte.nombre, None, competencia.tantos_presentismo,
None))
else:
lista_dtos.append(DTOCompetencia(competencia.id, competencia.nombre, competencia.tipo_puntuacion,
competencia.estado, competencia.reglamento, competencia.id_usuario,
usuario.nombre, competencia.tipo, competencia.cantidad_de_sets,
competencia.puntos_por_presentarse, competencia.puntos_por_ganar,
competencia.puntos_por_empate, competencia.deporte.nombre, None,
competencia.tantos_presentismo, competencia.permitir_empate))
return lista_dtos
def generar_fixture(self, id_competencia):
competencia = GestorBaseDeDatos.get_instance().listar_competencias(id_competencia=id_competencia)
if len(competencia.partidas) > 0:
GestorCompetencia.get_instance().eliminar_fixture(id_competencia=id_competencia)
competencia = GestorBaseDeDatos.get_instance().listar_competencias(id_competencia=id_competencia)
lista_participantes = competencia.participantes[:]
if len(lista_participantes) < 2:
raise FaltaDeDatos('No hay suficientes participantes en la competencia.')
sedes = competencia.sedes
cantidad_de_participantes = len(lista_participantes)
disponibilidad= 0
for lugar in sedes:
disponibilidad += lugar.disponibilidad
if (cantidad_de_participantes/2) > disponibilidad:
raise FaltaDeDatos('No hay suficiente disponibilidad para generar el fixture')
nombre_dummy = "Dummy" + competencia.nombre
if (cantidad_de_participantes % 2) == 1:
dummy = Participante(nombre= nombre_dummy, correo_electronico = nombre_dummy,
id_competencia = competencia.id)
lista_participantes.append(dummy)
cantidad_de_participantes = len(lista_participantes)
for fecha in range(cantidad_de_participantes - 1):
for partida in range(cantidad_de_participantes/2):
if lista_participantes[partida].nombre == nombre_dummy:
nueva_partida = Partida(estado='Finalizado', instancia= fecha+1,
participante_local = lista_participantes[partida],
participante_visitante = lista_participantes[cantidad_de_participantes - (partida + 1)])
elif lista_participantes[cantidad_de_participantes - (partida + 1)].nombre== nombre_dummy:
nueva_partida = Partida(estado='Finalizado', instancia= fecha+1,
participante_local = lista_participantes[partida],
participante_visitante = lista_participantes[cantidad_de_participantes - (partida + 1)])
else:
nueva_partida = Partida(estado='Creada', instancia= fecha+1,
participante_local = lista_participantes[partida],
participante_visitante = lista_participantes[cantidad_de_participantes - (partida + 1)])
competencia.partidas.append(nueva_partida)
lista_participantes.append(lista_participantes.pop(1))
competencia.estado = 'Planificada'
GestorBaseDeDatos.get_instance().modificar_competencia()
return 1
def eliminar_fixture(self, id_competencia):
from gestorparticipante import GestorParticipante
from gestorpartida import GestorPartida
competencia = GestorBaseDeDatos.get_instance().listar_competencias(id_competencia = id_competencia)
for participante in competencia.participantes:
nombre_dummy = 'Dummy' + competencia.nombre
if participante.nombre == nombre_dummy:
competencia.participantes.remove(participante)
GestorParticipante.get_instance().eliminar_participante(participante)
break
for partida in competencia.partidas:
GestorPartida.get_instance().eliminar_partida(partida)
def listar_participantes(self, id_competencia=None, id_participante=None):
lista_participantes = []
if id_participante is not None:
lista_participantes.append(
GestorBaseDeDatos.get_instance().listar_participantes(id_participante=id_participante)
)
else:
lista_participantes += GestorBaseDeDatos.get_instance().listar_participantes(id_competencia=id_competencia)
lista = []
competencia = GestorCompetencia.get_instance().listar_competencias(id_competencia=id_competencia)[0]
for participante in lista_participantes:
nombres_en_historial = []
for nombre in participante.historial_nombres:
nombres_en_historial.append(nombre.nombre)
dto_participante = DTOParticipante(
participante.id,
participante.nombre,
participante.correo_electronico,
competencia.nombre,
nombres_en_historial,
None,
)
lista.append(dto_participante)
return lista
def listar_partidas(self, id_participante=None, id_partida=None, id_competencia=None):
from gestorcompetencia import GestorCompetencia
lista_partidas = GestorBaseDeDatos.get_instance().listar_partidas(id_participante = id_participante,
id_partida = id_partida,
id_competencia = id_competencia)
if id_partida is not None:
lista_partidas = [lista_partidas]
lista_dtos = []
for partida in lista_partidas:
competencia = GestorCompetencia.get_instance().listar_competencias(id_competencia=partida.id_competencia)[0]
dto = DTOPartida(partida.id, partida.estado, partida.instancia, partida.local_presente,
partida.visitante_presente, partida.id_resultado, partida.participante_local.nombre,
partida.participante_visitante.nombre, competencia.permitir_empate,
competencia.tipo_puntuacion, competencia.cantidad_de_sets)
lista_dtos.append(dto)
return lista_dtos
def listar_resultado(self, id_partida):
partida = GestorBaseDeDatos.get_instance().listar_partidas(id_partida = id_partida)
if partida.resultado is None:
raise FaltaDeDatos('No existen Resultados para esta partida.')
if partida.resultado.tipo == 'porsets':
lista_sets = []
for sets in partida.resultado.sets:
dtoSet = DTOSet(sets.id, sets.puntaje_de_local, sets.puntaje_de_visitante,sets.numero)
lista_sets.append(dtoSet)
return DTOResultado(partida.resultado.id, partida.id, partida.resultado.tipo,partida.local_presente, partida.visitante_presente,
None, None, lista_sets)
if partida.resultado.tipo == 'porresultadofinal':
return DTOResultado(partida.resultado.id, partida.id, partida.resultado.tipo,partida.local_presente,partida.visitante_presente,
partida.resultado.resultado_de_local, partida.resultado.resultado_de_visitante, None)
if partida.resultado.tipo == 'porpuntuacion':
return DTOResultado(partida.resultado.id, partida.id, partida.resultado.tipo,partida.local_presente,partida.visitante_presente,
partida.resultado.puntos_de_local, partida.resultado.puntos_de_visitante, None)
def agregar_competencia(self, id_usuario, competencia):
user = GestorBaseDeDatos.get_instance().listar_usuario(id_usuario)
user.competencias.append(competencia)
GestorBaseDeDatos.get_instance().modificar_usuario()
def eliminar_participante(self, participante):
GestorBaseDeDatos.get_instance().eliminar_participante(participante)
def agregar_resultado(self, dto):
from gestorcompetencia import GestorCompetencia
partida = GestorBaseDeDatos.get_instance().listar_partidas(id_partida = dto.id_partida)
competencia = GestorCompetencia.get_instance().listar_competencias(id_competencia = partida.id_competencia)
cantidad_de_sets = competencia[0].cantidad_de_sets
resultado_new = None
if dto.tipo == 'porsets':
lista_de_sets = []
if not dto.local_presente:
for sets in range((cantidad_de_sets/2)+1):
new_set = Set( puntaje_de_local = 0, puntaje_de_visitante = 6, numero = sets+1)
lista_de_sets.append(new_set)
elif not dto.visitante_presente:
for sets in range((cantidad_de_sets/2)+1):
new_set = Set( puntaje_de_local = 6, puntaje_de_visitante = 0, numero = sets+1)
lista_de_sets.append(new_set)
else:
for dtoset in dto.lista_dto_sets:
new_set = Set( puntaje_de_local = dtoset.puntaje_local, puntaje_de_visitante = dtoset.puntaje_visitante,
numero = dtoset.numero_de_set)
lista_de_sets.append(new_set)
resultado_new = ResultadoPorSet(fecha = datetime.now().date(), sets = lista_de_sets)
elif dto.tipo == 'porresultadofinal':
if not dto.local_presente:
resultado_new = ResultadoPorResultadoFinal(fecha = datetime.now().date(), resultado_de_local = 0,
resultado_de_visitante = 1)
elif not dto.visitante_presente:
resultado_new = ResultadoPorResultadoFinal(fecha = datetime.now().date(), resultado_de_local = 1,
resultado_de_visitante = 0)
else:
resultado_new = ResultadoPorResultadoFinal(fecha = datetime.now().date(), resultado_de_local = dto.resultado_local,
resultado_de_visitante = dto.resultado_visitante)
elif dto.tipo == 'porpuntuacion':
dto_competencia = GestorCompetencia.get_instance().listar_competencias(id_competencia=partida.id_competencia)[0]
puntos_local = dto.resultado_local
puntos_visitante = dto.resultado_visitante
if not dto.local_presente:
puntos_local = 0
puntos_visitante = dto_competencia.tantos_presentismo
if not dto.visitante_presente:
puntos_visitante = 0
puntos_local = dto_competencia.tantos_presentismo
resultado_new = ResultadoPorPuntuacion(fecha = datetime.now().date(), puntos_de_local = puntos_local,
puntos_de_visitante = puntos_visitante)
if partida.resultado is None:
dtocompetencia = DTOCompetencia(partida.id_competencia, None, None, 'En Disputa',None, None, None, None, None, None,None,
None, None, None, None, None)
GestorCompetencia.get_instance().modificar_competencia(dtocompetencia)
partida.resultado = resultado_new
partida.visitante_presente = dto.visitante_presente
partida.local_presente = dto.local_presente
partida.estado = 'Finalizada'
partida.historial.append(resultado_new)
GestorBaseDeDatos.get_instance().modificar_partida()
lista_partidas = GestorBaseDeDatos.get_instance().listar_partidas(id_competencia = partida.id_competencia)
terminado = 0
for partidas in lista_partidas:
if partidas.estado in ['Finalizado', 'Finalizada']:
terminado += 1
if terminado == len(lista_partidas):
dtocompetencia = DTOCompetencia(partida.id_competencia,None, None, 'Finalizada', None, None, None, None, None, None, None,
None, None, None, None, None)
GestorCompetencia.get_instance().modificar_competencia(dtocompetencia)
return 1
def eliminar_partida(self, partida):
GestorBaseDeDatos.get_instance().eliminar_partida(partida)
def modificar_competencia(self, dto_competencia):
competencia = GestorBaseDeDatos.get_instance().listar_competencias(id_competencia = dto_competencia.id)
competencia.estado = dto_competencia.estado
GestorBaseDeDatos.get_instance().modificar_competencia()
def generar_tabla_posiciones(self, id_competencia):
competencia = GestorBaseDeDatos.get_instance().listar_competencias(id_competencia = id_competencia)
presentarse = competencia.puntos_por_presentarse
ganar = competencia.puntos_por_ganar
empate = competencia.puntos_por_empate
lista_dtos = []
lista_participantes = competencia.participantes
for participante in lista_participantes:
lista_partidas = competencia.partidas
puntos = 0
goles_a_favor = 0
goles_en_contra = 0
partidos_ganados = 0
partidos_perdidos = 0
partidos_empatados = 0
tipo = None
nombre_dummy = 'Dummy' + competencia.nombre
if participante.nombre == nombre_dummy:
continue
for partida in lista_partidas:
if partida.estado != 'Finalizada':
continue
if partida.resultado.tipo == 'porpuntuacion':
tipo = 'porpuntuacion'
if partida.participante_local == participante:
if partida.local_presente:
puntos += presentarse
if partida.resultado.puntos_de_local > partida.resultado.puntos_de_visitante:
puntos += ganar
partidos_ganados += 1
goles_a_favor += partida.resultado.puntos_de_local
goles_en_contra += partida.resultado.puntos_de_visitante
elif partida.resultado.puntos_de_local < partida.resultado.puntos_de_visitante:
partidos_perdidos += 1
goles_a_favor += partida.resultado.puntos_de_local
goles_en_contra += partida.resultado.puntos_de_visitante
else:
puntos += empate
partidos_empatados += 1
goles_a_favor += partida.resultado.puntos_de_local
goles_en_contra += partida.resultado.puntos_de_visitante
else:
goles_en_contra += partida.resultado.puntos_de_visitante
if partida.participante_visitante == participante:
if partida.visitante_presente:
puntos += presentarse
if partida.resultado.puntos_de_visitante > partida.resultado.puntos_de_local:
puntos += ganar
partidos_ganados += 1
goles_a_favor += partida.resultado.puntos_de_visitante
goles_en_contra += partida.resultado.puntos_de_local
elif partida.resultado.puntos_de_visitante < partida.resultado.puntos_de_local:
partidos_perdidos += 1
goles_a_favor += partida.resultado.puntos_de_visitante
goles_en_contra += partida.resultado.puntos_de_local
else:
puntos += empate
partidos_empatados += 1
goles_a_favor += partida.resultado.puntos_de_visitante
goles_en_contra += partida.resultado.puntos_de_local
else:
goles_en_contra += partida.resultado.puntos_de_local
if partida.resultado.tipo == 'porresultadofinal':
tipo = 'porresultadofinal'
if partida.participante_local == participante and partida.local_presente:
puntos += presentarse
if partida.resultado.resultado_de_local == 1:
puntos += ganar
partidos_ganados += 1
elif partida.resultado.resultado_de_local == 0.5:
partidos_empatados += 1
puntos += empate
else:
partidos_perdidos += 1
if partida.participante_visitante == participante and partida.visitante_presente:
puntos += presentarse
if partida.resultado.resultado_de_visitante == 1:
partidos_ganados += 1
puntos += ganar
elif partida.resultado.resultado_de_visitante == 0.5:
partidos_empatados += 1
puntos += empate
else:
partidos_perdidos += 1
if partida.resultado.tipo == 'porsets':
tipo = 'porsets'
if partida.participante_local == participante:
if partida.local_presente:
puntos += presentarse
lista_sets = partida.resultado.sets
ganador_local = 0
ganador_visitante = 0
for sets in lista_sets:
if sets.puntaje_de_local > sets.puntaje_de_visitante:
ganador_local += 1
goles_a_favor += sets.puntaje_de_local
goles_en_contra += sets.puntaje_de_visitante
if sets.puntaje_de_local < sets.puntaje_de_visitante:
ganador_visitante += 1
goles_a_favor += sets.puntaje_de_local
goles_en_contra += sets.puntaje_de_visitante
if ganador_local > ganador_visitante:
puntos += ganar
partidos_ganados += 1
else:
partidos_perdidos += + 1
else:
lista_sets = partida.resultado.sets
for sets in lista_sets:
goles_en_contra += sets.puntaje_de_visitante
if partida.participante_visitante == participante:
if partida.visitante_presente:
puntos += presentarse
lista_sets = partida.resultado.sets
ganador_local = 0
ganador_visitante = 0
for sets in lista_sets:
if sets.puntaje_de_local > sets.puntaje_de_visitante:
ganador_local += 1
goles_a_favor += sets.puntaje_de_visitante
goles_en_contra += sets.puntaje_de_local
if sets.puntaje_de_local < sets.puntaje_de_visitante:
ganador_visitante += 1
goles_a_favor += sets.puntaje_de_visitante
goles_en_contra += sets.puntaje_de_local
if ganador_local < ganador_visitante:
puntos += ganar
partidos_ganados += 1
else:
partidos_perdidos += 1
else:
lista_sets = partida.resultado.sets
for sets in lista_sets:
goles_en_contra += sets.puntaje_de_local
if tipo == 'porpuntuacion':
dto = DTOTabla(participante.id, participante.nombre, puntos, partidos_ganados, partidos_empatados,
partidos_perdidos, goles_a_favor, goles_en_contra)
lista_dtos.append(dto)
if tipo == 'porresultadofinal':
dto = DTOTabla(participante.id, participante.nombre, puntos, partidos_ganados, partidos_empatados,
partidos_perdidos, goles_a_favor, goles_en_contra)
lista_dtos.append(dto)
if tipo == 'porsets':
dto = DTOTabla(participante.id, participante.nombre, puntos,partidos_ganados, 0, partidos_perdidos,
goles_a_favor, goles_en_contra)
lista_dtos.append(dto)
GestorCompetencia.get_instance().ordenar_tabla(lista = lista_dtos)
return lista_dtos
def obtener_usuario(self, id_usuario):
"""Obtiene, teniendo un id de usuario, el objeto Usuario correspondiente a este id"""
user = GestorBaseDeDatos.get_instance().listar_usuario(id_usuario)
return user
def listar_deportes(self):
deportes = GestorBaseDeDatos.get_instance().listar_deportes()
lista_deportes = []
for d in deportes:
lista_deportes.append(d.nombre)
return lista_deportes
