def setUpTestData(cls):
super(ViewAddDesafioLadderTestCase, cls).setUpTestData()
# Configurar jogadores
criar_jogadores_teste()
cls.sena = Jogador.objects.get(nick='sena')
cls.teets = Jogador.objects.get(nick='teets')
cls.mad = Jogador.objects.get(nick='mad')
# Jogadores fora da ladder
cls.new_1 = criar_jogador_teste('new1')
cls.new_2 = criar_jogador_teste('new2')
# Stage
cls.stage = criar_stage_teste()
# Configurar stage como válida
StageValidaLadder.objects.create(stage=cls.stage)
# Personagens
criar_personagens_teste()
cls.marth = Personagem.objects.get(nome='Marth')
cls.fox = Personagem.objects.get(nome='Fox')
# Criar ladders para verificar que adicionar desafio não as afeta
criar_ladder_teste()
# Preparar mês anterior para histórico
data_atual = timezone.now().date()
cls.mes, cls.ano = mes_ano_ant(data_atual.month, data_atual.year)
criar_ladder_historico_teste(cls.ano, cls.mes)
def setUpTestData(cls):
super(ViewCancelarDesafioLadderTestCase, cls).setUpTestData()
criar_jogadores_teste()
cls.teets = Jogador.objects.get(nick='teets') # Admin, com desafios
cls.saraiva = Jogador.objects.get(nick='saraiva') # Admin, sem desafios
cls.sena = Jogador.objects.get(nick='sena') # Não-admin, com desafios
cls.mad = Jogador.objects.get(nick='mad') # Não-admin, sem desafios
# Criar ladders para verificar que adicionar desafio não as afeta
criar_ladder_teste()
# Preparar mês anterior para histórico
horario_atual = timezone.localtime()
data_atual = horario_atual.date()
cls.mes, cls.ano = mes_ano_ant(data_atual.month, data_atual.year)
criar_ladder_historico_teste(cls.ano, cls.mes)
# Criar desafios para ladder
horario_historico = horario_atual.replace(year=cls.ano, month=cls.mes)
cls.desafio_ladder = criar_desafio_ladder_simples_teste(cls.sena, cls.teets, 3, 1,
horario_atual.replace(day=10), False, cls.sena)
cls.desafio_ladder_volta = criar_desafio_ladder_simples_teste(cls.teets, cls.sena, 3, 1,
horario_atual.replace(day=20), False, cls.sena)
cls.desafio_ladder_historico = criar_desafio_ladder_simples_teste(cls.sena, cls.teets, 3, 1,
horario_historico, False, cls.sena)
def setUpTestData(cls):
super(JogadorTestCase, cls).setUpTestData()
criar_jogadores_teste()
cls.teets = Jogador.objects.get(nick='teets')
cls.sena = Jogador.objects.get(nick='sena')
cls.saraiva = Jogador.objects.get(nick='saraiva')
cls.tiovsky = Jogador.objects.get(nick='tiovsky')
# Personagens
criar_personagens_teste()
# Stage
cls.stage = criar_stage_teste()
# Criar ladders para verificar que adicionar desafio não as afeta
criar_ladder_teste()
cls.horario_mes = timezone.localtime().replace(day=15)
cls.horario_atual = cls.horario_mes + datetime.timedelta(minutes=1)
cls.mes, cls.ano = mes_ano_ant(cls.horario_mes.month,
cls.horario_mes.year)
cls.horario_historico = cls.horario_mes.replace(year=cls.ano,
month=cls.mes)
criar_ladder_historico_teste(cls.ano, cls.mes)
# Adicionar desafios
cls.desafio_ladder = criar_desafio_ladder_simples_teste(
cls.sena, cls.teets, 3, 1, cls.horario_mes, False, cls.teets)
cls.desafio_ladder_historico = criar_desafio_ladder_simples_teste(
cls.sena, cls.teets, 1, 3, cls.horario_historico, False, cls.teets)
def setUpTestData(cls):
super(ViewValidarDesafioLadderTestCase, cls).setUpTestData()
# Jogadores
criar_jogadores_teste()
# Personagens e estágios
criar_personagens_teste()
criar_stage_teste()
# Buscar jogadores a serem usados nos testes
cls.sena = Jogador.objects.get(nick='sena')
cls.teets = Jogador.objects.get(nick='teets')
cls.mad = Jogador.objects.get(nick='mad')
cls.saraiva = Jogador.objects.get(nick='saraiva')
cls.tiovsky = Jogador.objects.get(nick='tiovsky') # Último lugar da ladder
# Criar ladders
cls.ladder_atual = criar_ladder_teste()
# Preparar mês anterior para histórico
data_atual = timezone.now().date()
cls.mes, cls.ano = mes_ano_ant(data_atual.month, data_atual.year)
criar_ladder_historico_teste(cls.ano, cls.mes)
# Criar desafios para ladder
horario_atual = timezone.now().replace(day=15)
horario_historico = horario_atual.replace(year=cls.ano, month=cls.mes)
cls.desafio_ladder_simples = criar_desafio_ladder_simples_teste(cls.sena, cls.teets, 3, 1,
horario_atual.replace(hour=6), False, cls.sena)
cls.desafio_ladder_simples_validado = criar_desafio_ladder_simples_teste(cls.sena, cls.teets, 3, 1,
horario_atual.replace(hour=7), False, cls.sena)
cls.desafio_ladder_simples_historico = criar_desafio_ladder_simples_teste(cls.sena, cls.teets, 3, 1,
horario_historico.replace(hour=6), False, cls.sena)
cls.desafio_ladder_coringa_derrota = criar_desafio_ladder_simples_teste(cls.mad, cls.teets, 2, 3,
horario_atual.replace(hour=10), True, cls.mad)
cls.desafio_ladder_coringa_vitoria = criar_desafio_ladder_simples_teste(cls.mad, cls.teets, 3, 1,
horario_atual.replace(hour=11), True, cls.mad)
# Adicionar novo entrante na ladder
cls.new = criar_jogador_teste('new')
cls.desafio_ladder_novo_entrante = criar_desafio_ladder_simples_teste(cls.new, cls.tiovsky, 3, 1,
horario_atual.replace(hour=8), False, cls.tiovsky)
# Adicionar segundo novo entrante na ladder
cls.new_2 = criar_jogador_teste('new2')
cls.desafio_ladder_novos_entrantes = criar_desafio_ladder_simples_teste(cls.new, cls.new_2, 3, 1,
horario_atual.replace(hour=9), False, cls.new_2)
def setUpTestData(cls):
super(ViewRemoverJogadorLadderTestCase, cls).setUpTestData()
# Jogadores
criar_jogadores_teste()
cls.teets = Jogador.objects.get(nick='teets') # Admin, com desafios
cls.saraiva = Jogador.objects.get(
nick='saraiva') # Admin, sem desafios
cls.sena = Jogador.objects.get(nick='sena') # Não-admin, com desafios
cls.mad = Jogador.objects.get(nick='mad') # Não-admin, sem desafios
cls.tiovsky = Jogador.objects.get(
nick='tiovsky') # Não-admin, sem desafios
# Personagens
criar_personagens_teste()
cls.fox = Personagem.objects.get(nome='Fox')
cls.marth = Personagem.objects.get(nome='Marth')
# Stage
cls.stage = criar_stage_teste()
# Criar ladders para verificar que adicionar desafio não as afeta
criar_ladder_teste()
# Preparar mês anterior para histórico
cls.horario_atual = timezone.localtime()
cls.mes, cls.ano = mes_ano_ant(cls.horario_atual.month,
cls.horario_atual.year)
criar_ladder_historico_teste(cls.ano, cls.mes)
# Criar desafios para ladder
cls.horario_historico = cls.horario_atual.replace(year=cls.ano,
month=cls.mes)
cls.desafio_ladder = criar_desafio_ladder_simples_teste(
cls.sena, cls.teets, 3, 1, cls.horario_atual.replace(day=15),
False, cls.teets)
cls.desafio_ladder_historico = criar_desafio_ladder_simples_teste(
cls.sena, cls.teets, 3, 1, cls.horario_historico.replace(day=15),
False, cls.sena)
def setUpTestData(cls):
super(RemocaoJogadorFormTestCase, cls).setUpTestData()
# Configurar jogador
criar_jogadores_teste()
criar_ladder_teste()
cls.mad = Jogador.objects.get(user__username='******') # 4 na ladder
cls.sena = Jogador.objects.get(user__username='******') # 3 na ladder
cls.teets = Jogador.objects.get(user__username='******') # 1 na ladder
cls.tiovsky = Jogador.objects.get(
user__username='******') # 10 na ladder
cls.new = criar_jogador_teste('new') # Novo entrande na ladder
# Preparar mês anterior para histórico
cls.horario_atual = timezone.localtime()
cls.mes, cls.ano = mes_ano_ant(cls.horario_atual.month,
cls.horario_atual.year)
criar_ladder_historico_teste(cls.ano, cls.mes)
def setUpTestData(cls):
super(ViewCancelarRemocaoJogadorLadderTestCase, cls).setUpTestData()
criar_jogadores_teste()
cls.teets = Jogador.objects.get(nick='teets') # Admin, com desafios
cls.saraiva = Jogador.objects.get(
nick='saraiva') # Admin, sem desafios
cls.sena = Jogador.objects.get(nick='sena') # Não-admin, com desafios
cls.mad = Jogador.objects.get(nick='mad') # Não-admin, sem desafios
cls.tiovsky = Jogador.objects.get(
nick='tiovsky') # Não-admin, sem desafios
# Criar ladders para verificar que adicionar desafio não as afeta
criar_ladder_teste()
# Preparar mês anterior para histórico
horario_atual = timezone.localtime()
data_atual = horario_atual.date()
cls.mes, cls.ano = mes_ano_ant(data_atual.month, data_atual.year)
criar_ladder_historico_teste(cls.ano, cls.mes)
# Criar remoção por admin
cls.remocao_admin = RemocaoJogador.objects.create(
jogador=cls.sena,
data=timezone.localtime() - datetime.timedelta(days=2),
admin_removedor=cls.teets,
posicao_jogador=3,
remocao_por_inatividade=False)
remover_jogador(cls.remocao_admin)
# Criar remoção por inatividade
cls.remocao_inatividade = RemocaoJogador.objects.create(
jogador=cls.tiovsky,
data=timezone.localtime() - datetime.timedelta(days=1),
admin_removedor=cls.teets,
posicao_jogador=9,
remocao_por_inatividade=True)
remover_jogador(cls.remocao_inatividade)
def setUpTestData(cls):
super(DesafioLadderFormTestCase, cls).setUpTestData()
# Configurar jogador
criar_jogadores_teste()
criar_ladder_teste()
cls.jogador_pos_5 = Jogador.objects.get(
user__username='******') # 5 na ladder
cls.jogador_pos_4 = Jogador.objects.get(
user__username='******') # 4 na ladder
cls.jogador_pos_7 = Jogador.objects.get(
user__username='******') # 7 na ladder
cls.jogador_pos_8 = Jogador.objects.get(
user__username='******') # 8 na ladder
cls.teets = Jogador.objects.get(user__username='******') # 1 na ladder
cls.new = criar_jogador_teste('new') # Novo entrande na ladder
# Preparar mês anterior para histórico
data_atual = timezone.localtime().date()
cls.mes, cls.ano = mes_ano_ant(data_atual.month, data_atual.year)
criar_ladder_historico_teste(cls.ano, cls.mes)
def handle(self, *args, **options):
# Não rodar em produção
if settings.DEBUG == False:
return
mes_ano_validos = list()
for ano, mes in HistoricoLadder.objects.filter(ano__lte=2002).order_by(
'ano',
'mes').values('ano',
'mes').distinct().values_list('ano', 'mes'):
ladder_mes = HistoricoLadder.objects.filter(
ano=ano, mes=mes).order_by('posicao').values_list(
'jogador__nick', 'posicao')
if ('Mad', 6) in ladder_mes:
if ('Niz', 10) in ladder_mes:
if ('Blöwer', 4) in ladder_mes:
if ('C0ox', 9) in ladder_mes:
if ('Bacabau', 5) in ladder_mes:
if ('Yalda', 3) in ladder_mes:
mes_ano_validos.append((mes, ano))
print('qtd validos:', len(mes_ano_validos))
for mes, ano in mes_ano_validos:
print(
f'{mes}/{ano}:',
HistoricoLadder.objects.filter(
ano=ano, mes=mes).order_by('posicao').values_list(
'jogador__nick', 'posicao'))
if 2 == 2:
return
# HistoricoLadder.objects.filter(ano__lte=2002).delete()
try:
mes = 12
ano = 2001
nova_ladder = InicioLadder.objects.all().select_related(
'jogador').order_by('posicao')
# Decrementar mes ano para poder copiar
mes, ano = mes_ano_ant(mes, ano)
nova_opcao = copiar_ladder_como_historico(nova_ladder, mes, ano)
opcoes_ladder = [
nova_opcao,
]
print('Inicial:',
nova_ladder.values_list('jogador__nick', 'posicao'))
with open('templates/desafios.json', 'r') as arq:
desafios = json.load(arq)
# print(desafios)
for desafio in reversed(desafios):
with transaction.atomic():
jogador_1 = desafio['jogador_1']
score_1 = desafio['score_jogador_1']
jogador_2 = desafio['jogador_2']
score_2 = desafio['score_jogador_2']
print('-----------------------------------')
print(jogador_1, jogador_2)
# Guardar próximo índice a ser avaliado
indice_prox = 0
# Guardar opções que serão removidas
opcoes_a_remover = list()
# Percorrer todas as possibilidades
for indice, opcao_ladder in enumerate(opcoes_ladder):
# Barrar novas entradas na lista
if indice < indice_prox:
continue
indice_prox = indice + 1
# if len(opcoes_ladder) < 4:
# print([situacao.values_list('jogador__nick', 'posicao') for situacao in opcoes_ladder])
print(
f'Indice atual: {indice+1} de {len(opcoes_ladder)}'
)
# Desfazer desafio
posicao_1 = opcao_ladder.get(
jogador__nick=jogador_1).posicao
posicao_2 = opcao_ladder.get(
jogador__nick=jogador_2).posicao
# print(f'Luta: {jogador_1} em {posicao_1} e {jogador_2} em {posicao_2}')
# print(opcao_ladder.values_list('jogador__nick', 'posicao'))
# jogador_verificar_1 = 'CPU'
# jogador_verificar_2 = 'Yalda'
# posicao_verificar_1 = opcao_ladder.get(jogador__nick=jogador_verificar_1).posicao
# posicao_verificar_2 = opcao_ladder.get(jogador__nick=jogador_verificar_2).posicao
# print(f'Posições a verificar: {jogador_verificar_1} em {posicao_verificar_1} e {jogador_verificar_2} em {posicao_verificar_2}')
# Diferença de mais de 2 posições tem de ser removida
if abs(posicao_1 - posicao_2) > 2:
# print(f'Retirar por diferença maior de 2 posições, {jogador_1}:{posicao_1} e {jogador_2}:{posicao_2}')
opcoes_a_remover.append(opcao_ladder)
continue
# Se 1 está na frente, e possui o score maior, voltar posição
if posicao_1 < posicao_2 and score_1 > score_2:
# Gerar novas possibilidades
# A opção padrão é sempre defesa
# print('Defesa', jogador_1)
# Apenas adiciona situação de vitória se ganhador estiver 1 na frente
if posicao_1 + 1 == posicao_2:
mes, ano = mes_ano_ant(mes, ano)
opcao_2_diferenca = copiar_ladder_como_historico(
opcao_ladder, mes, ano)
# print('Voltar 2 posições', jogador_1)
opcao_2_diferenca.filter(
posicao=posicao_1).update(posicao=0)
opcao_2_diferenca.filter(
posicao=posicao_2).update(
posicao=posicao_1)
opcao_2_diferenca.filter(
posicao=(posicao_2 + 1)).update(
posicao=(posicao_1 + 1))
opcao_2_diferenca.filter(posicao=0).update(
posicao=(posicao_2 + 1))
# print('Resultado:', opcao_2_diferenca)
opcoes_ladder.insert(
indice + 1, opcao_2_diferenca)
indice_prox += 1
mes, ano = mes_ano_ant(mes, ano)
opcao_1_diferenca = copiar_ladder_como_historico(
opcao_ladder, mes, ano)
# print('Voltar 1 posição', jogador_1)
opcao_1_diferenca.filter(
posicao=posicao_1).update(posicao=0)
opcao_1_diferenca.filter(
posicao=posicao_2).update(
posicao=posicao_1)
opcao_1_diferenca.filter(posicao=0).update(
posicao=posicao_2)
# print('Resultado:', opcao_1_diferenca)
opcoes_ladder.insert(
indice + 2, opcao_1_diferenca)
indice_prox += 1
# print(nova_ladder.values_list('jogador__nick', 'posicao'))
elif posicao_1 < posicao_2 and score_1 < score_2:
# Se jogador 1 está na frente mas perdeu, remover da lista
# print('Retirar por jogador 1 estar na frente mas ter perdido')
opcoes_a_remover.append(opcao_ladder)
continue
# # Se 2 está na frente, e possui o score maior, voltar posição
elif posicao_2 < posicao_1 and score_2 > score_1:
# Gerar novas possibilidades
# A opção padrão é sempre defesa
# print('Defesa', jogador_2)
# Apenas adiciona situação de vitória se ganhador estiver 1 na frente
if posicao_2 + 1 == posicao_1:
mes, ano = mes_ano_ant(mes, ano)
opcao_2_diferenca = copiar_ladder_como_historico(
opcao_ladder, mes, ano)
# print('Voltar 2 posições', jogador_2)
opcao_2_diferenca.filter(
posicao=posicao_2).update(posicao=0)
opcao_2_diferenca.filter(
posicao=posicao_1).update(
posicao=posicao_2)
opcao_2_diferenca.filter(
posicao=(posicao_1 + 1)).update(
posicao=(posicao_2 + 1))
opcao_2_diferenca.filter(posicao=0).update(
posicao=(posicao_1 + 1))
# print('Resultado:', opcao_2_diferenca)
opcoes_ladder.insert(
indice + 1, opcao_2_diferenca)
indice_prox += 1
mes, ano = mes_ano_ant(mes, ano)
opcao_1_diferenca = copiar_ladder_como_historico(
opcao_ladder, mes, ano)
# print('Voltar 1 posição', jogador_2)
opcao_1_diferenca.filter(
posicao=posicao_2).update(posicao=0)
opcao_1_diferenca.filter(
posicao=posicao_1).update(
posicao=posicao_2)
opcao_1_diferenca.filter(posicao=0).update(
posicao=posicao_1)
# print('Resultado:', opcao_1_diferenca)
opcoes_ladder.insert(
indice + 2, opcao_1_diferenca)
indice_prox += 1
# print(nova_ladder.values_list('jogador__nick', 'posicao'))
elif posicao_2 < posicao_1 and score_2 < score_1:
# Se jogador 1 está na frente mas perdeu, remover da lista
# print('Retirar por jogador 2 estar na frente mas ter perdido')
opcoes_a_remover.append(opcao_ladder)
continue
# Aplicar remoções
print(
f'Remover {len(opcoes_a_remover)} de {len(opcoes_ladder)}'
)
for remover in opcoes_a_remover:
remover.delete()
opcoes_ladder.remove(remover)
print(len(opcoes_ladder))
if len(opcoes_ladder) == 1:
print(opcoes_ladder[0].values_list('jogador__nick',
'posicao'))
elif len(opcoes_ladder) >= 3:
print(opcoes_ladder[0].values_list('jogador__nick',
'posicao'))
print(opcoes_ladder[1].values_list('jogador__nick',
'posicao'))
print(opcoes_ladder[2].values_list('jogador__nick',
'posicao'))
except:
if score_1 == 3:
print(
f'Vitória de {jogador_1} em {posicao_1}, {jogador_2} em {posicao_2}',
opcao_ladder.values_list('jogador__nick', 'posicao'))
elif score_2 == 3:
print(
f'{jogador_1} em {posicao_1}, Vitória de {jogador_2} em {posicao_2}',
opcao_ladder.values_list('jogador__nick', 'posicao'))
raise
def posicao_em(self, data_hora):
"""Retora a posição do jogador na ladder na data/hora especificada"""
# Verificar Season para data/hora
season = Season.objects.filter(
data_inicio__lte=data_hora.date()).order_by('-data_inicio')[0]
# Buscar última remoção da ladder, posição será definida a partir de sua data
if RemocaoJogador.objects.filter(
jogador=self,
data__lt=data_hora,
data__gte=season.data_hora_inicio).exists():
data_inicial = RemocaoJogador.objects.filter(
jogador=self).order_by('-data')[0].data
desafios_validados_considerando_remocao = DesafioLadder.validados.na_season(
season).filter(data_hora__gt=data_inicial)
else:
data_inicial = None
desafios_validados_considerando_remocao = DesafioLadder.validados.na_season(
season)
# Buscar último desafio participado
desafio_mais_recente = None
if desafios_validados_considerando_remocao.filter(
data_hora__lt=data_hora).filter(
Q(desafiante=self) | Q(desafiado=self)).exists():
desafio_mais_recente = desafios_validados_considerando_remocao.filter(data_hora__lt=data_hora) \
.filter(Q(desafiante=self) | Q(desafiado=self)).annotate(
posicao=Case(When(Q(desafiante=self) & Q(score_desafiante__gt=F('score_desafiado')), then=F('posicao_desafiado')),
When(Q(desafiante=self) & Q(score_desafiante__lt=F('score_desafiado')), then=F('posicao_desafiante')),
When(Q(desafiado=self) & Q(score_desafiante__gt=F('score_desafiado')), then=F('posicao_desafiado') + 1),
When(Q(desafiado=self) & Q(score_desafiante__lt=F('score_desafiado')), then=F('posicao_desafiado')))) \
.order_by('-data_hora')[0]
if desafio_mais_recente:
# print(f'Desafio mais recente de {self}: {desafio_mais_recente.id} com {desafio_mais_recente.desafiante} VS {desafio_mais_recente.desafiado}')
posicao = desafio_mais_recente.posicao
# Buscar alterações feitas por remoções de outros jogadores
posicao += (ResultadoRemocaoJogador.objects.filter(remocao__data__range=[desafio_mais_recente.data_hora, data_hora], jogador=self) \
.exclude(remocao__data=data_hora).aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0)
# print(self, ResultadoDesafioLadder.objects.filter(jogador=self, desafio_ladder__data_hora__range=[desafio_mais_recente.data_hora, data_hora]) \
# .exclude(desafio_ladder=desafio_mais_recente).exclude(desafio_ladder__data_hora=data_hora) \
# .aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0)
# Buscar alterações feitas por desafios de outros jogadores
posicao += (ResultadoDesafioLadder.objects.filter(jogador=self, desafio_ladder__data_hora__range=[desafio_mais_recente.data_hora, data_hora]) \
.filter(desafio_ladder__admin_validador__isnull=False, desafio_ladder__cancelamentodesafioladder__isnull=True) \
.exclude(desafio_ladder=desafio_mais_recente).exclude(desafio_ladder__data_hora=data_hora) \
.aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0)
# Buscar alterações feitas por decaimentos de outros jogadores
posicao += (ResultadoDecaimentoJogador.objects.filter(jogador=self, decaimento__data__range=[desafio_mais_recente.data_hora, data_hora]) \
.exclude(decaimento__data=data_hora) \
.aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0)
return posicao
# Se não houver desafios cadastrados, verificar última ladder
# Definir ultima ladder
mes, ano = mes_ano_ant(data_hora.month, data_hora.year)
if HistoricoLadder.objects.filter(ano=ano, mes=mes).exists():
# Se houver remoção e ela ocorrer no mês atual, ignorar busca e retornar como novo entrante
if data_inicial and data_inicial.month == data_hora.month and data_inicial.year == data_hora.year:
return 0
ultima_ladder = HistoricoLadder.objects.filter(ano=ano, mes=mes)
else:
# Se houver remoção, ignorar busca por ladder inicial
if data_inicial:
return 0
ultima_ladder = InicioLadder.objects.all()
if ultima_ladder.filter(jogador=self).exists():
posicao = ultima_ladder.get(jogador=self).posicao
# print(self, ResultadoDesafioLadder.objects.filter(jogador=self, desafio_ladder__data_hora__lt=data_hora) \
# .aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0)
# Buscar alterações feitas por alterações de outros jogadores
if HistoricoLadder.objects.filter(ano=ano, mes=mes).exists():
# Remoções
posicao += (ResultadoRemocaoJogador.objects.filter(remocao__data__lt=data_hora, jogador=self) \
.filter(remocao__data__month=data_hora.month, remocao__data__year=data_hora.year)
.aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0)
# posicao -= RemocaoJogador.objects.filter(data__lt=data_hora, posicao_jogador__lt=posicao) \
# .filter(data__month=data_hora.month, data__year=data_hora.year).count()
# Desafios
posicao += (ResultadoDesafioLadder.objects.filter(jogador=self, desafio_ladder__data_hora__lt=data_hora) \
.filter(desafio_ladder__data_hora__month=data_hora.month, desafio_ladder__data_hora__year=data_hora.year,
desafio_ladder__admin_validador__isnull=False, desafio_ladder__cancelamentodesafioladder__isnull=True) \
.aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0)
# Decaimentos
posicao += (ResultadoDecaimentoJogador.objects.filter(jogador=self, decaimento__data__lt=data_hora) \
.filter(decaimento__data__month=data_hora.month, decaimento__data__year=data_hora.year)
.aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0)
else:
# Remoções
# posicao -= RemocaoJogador.objects.filter(data__lt=data_hora, posicao_jogador__lt=posicao).count()
posicao += (ResultadoRemocaoJogador.objects.filter(remocao__data__lt=data_hora, remocao__data__gte=season.data_hora_inicio,
jogador=self).aggregate(alteracao_total= \
Sum('alteracao_posicao'))['alteracao_total'] or 0)
# Desafios
posicao += (ResultadoDesafioLadder.objects.filter(jogador=self, desafio_ladder__data_hora__lt=data_hora,
desafio_ladder__data_hora__gte=season.data_hora_inicio, desafio_ladder__admin_validador__isnull=False,
desafio_ladder__cancelamentodesafioladder__isnull=True) \
.aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0)
# Decaimentos
posicao += (ResultadoDecaimentoJogador.objects.filter(jogador=self, decaimento__data__lt=data_hora,
decaimento__data__gte=season.data_hora_inicio) \
.aggregate(alteracao_total=Sum('alteracao_posicao'))['alteracao_total'] or 0)
return posicao
# Novos entrantes começam na posição 0
return 0
def testa_gerar_primeira_season(self):
"""Testa gerar primeira season"""
criar_jogadores_teste()
# Pegar objetos de jogador de acordo com sua posição
jogador_pos_1 = Jogador.objects.get(nick='teets')
jogador_pos_2 = Jogador.objects.get(nick='saraiva')
jogador_pos_3 = Jogador.objects.get(nick='sena')
jogador_pos_4 = Jogador.objects.get(nick='mad')
jogador_pos_5 = Jogador.objects.get(nick='blöwer')
jogador_pos_6 = Jogador.objects.get(nick='frodo')
jogador_pos_7 = Jogador.objects.get(nick='dan')
jogador_pos_8 = Jogador.objects.get(nick='phils')
jogador_pos_9 = Jogador.objects.get(nick='rata')
jogador_pos_10 = Jogador.objects.get(nick='tiovsky')
criar_season_teste(
data_inicio=timezone.localdate() - datetime.timedelta(days=30),
data_fim=timezone.localdate() - datetime.timedelta(days=1))
criar_ladder_inicial_teste()
criar_ladder_teste()
horario_atual = timezone.localtime()
ano, mes = mes_ano_ant(horario_atual.month, horario_atual.year)
criar_ladder_historico_teste(ano, mes)
# Criar desafios
desafio_ladder = criar_desafio_ladder_simples_teste(
jogador_pos_3, jogador_pos_1, 3, 1, horario_atual, False,
jogador_pos_1)
validar_desafio_ladder_teste(desafio_ladder, jogador_pos_1)
criar_desafio_ladder_simples_teste(jogador_pos_4, jogador_pos_2, 3, 1,
horario_atual, False, jogador_pos_1)
# Pegar situação da ladder inicial antes
ladder_inicial_antes = list(
InicioLadder.objects.all().order_by('posicao').values_list(
'jogador', 'posicao'))
# Pegar situação da ladder atual antes
ladder_atual_antes = list(
PosicaoLadder.objects.all().order_by('posicao').values_list(
'jogador', 'posicao'))
guardar_dados_season_anterior()
apagar_ladder_season_anterior()
gerar_nova_season()
self.assertFalse(HistoricoLadder.objects.exists())
self.assertEqual(DesafioLadder.objects.count(), 1)
self.assertTrue(
DesafioLadder.objects.filter(id=desafio_ladder.id).exists())
# Validar ladder inicial e atual
ladder_inicial_apos = list(
InicioLadder.objects.all().order_by('posicao').values_list(
'jogador', 'posicao'))
ladder_atual_apos = list(
PosicaoLadder.objects.all().order_by('posicao').values_list(
'jogador', 'posicao'))
self.assertEqual(len(ladder_inicial_antes), len(ladder_inicial_apos))
for situacao_antes, situacao_apos in zip(ladder_inicial_antes,
ladder_inicial_apos):
self.assertNotEqual(situacao_antes, situacao_apos)
self.assertEqual(len(ladder_atual_antes), len(ladder_atual_apos))
for situacao_antes, situacao_apos in zip(ladder_atual_antes,
ladder_atual_apos):
self.assertNotEqual(situacao_antes, situacao_apos)