def compute(self, user_profile):
result = 0
games_by_player = GameRepository.get_by_profile(user_profile)
victories_by_player = GameRepository.filter_by_victory(games_by_player)
victories_with_mage_down = GameRepository.filter_by_at_least_one_mage_died(
victories_by_player)
victories_with_mage_down = victories_with_mage_down.count()
if victories_with_mage_down > 0:
result = 1
if victories_with_mage_down >= 10:
result = 2
return result
def compute_nemesis_data(nemesis):
game_queryset = GameRepository.get_all_game_by_nemesis(nemesis=nemesis)
nemesis.game_number = game_queryset.count()
win_rate = GameService.get_win_rate(game_queryset)
if win_rate is not None:
nemesis.win_rate = win_rate
nemesis.save()
def compute_mage_data(mage):
game_queryset = GameRepository.get_all_game_by_mage(mage=mage)
mage.game_number = game_queryset.count()
win_rate = GameService.get_win_rate(game_queryset)
if win_rate is not None:
mage.win_rate = win_rate
mage.save()
def compute_card_data(card):
game_queryset = GameRepository.get_all_game_by_card(card=card)
card.game_number = game_queryset.count()
win_rate = GameService.get_win_rate(game_queryset)
if win_rate is not None:
card.win_rate = win_rate
card.save()
def get_database_data(filters_mage):
games = GameRepository.get_by_mage_list(filters_mage)
available_average_ether_cost = list(
set(filter(None, map(lambda game: game.average_ether_cost,
games))))
available_average_ether_cost.sort()
average_ether_cost_win_rate = []
for average_ether_cost in available_average_ether_cost:
games = GameRepository.get_by_average_ether_cost(
average_ether_cost)
win_rate = GameService.get_win_rate(games)
if win_rate is not None:
average_ether_cost_win_rate.append({
"average_ether_cost": average_ether_cost,
"win_rate": win_rate,
})
return average_ether_cost_win_rate
def get_database_data(filters_mage):
games = GameRepository.get_by_mage_list(filters_mage)
available_damage_possibility = list(
set(map(lambda game: game.total_damage, games)))
available_damage_possibility.sort()
games_available_damage = []
for available_damage in available_damage_possibility:
games = GameRepository.get_by_total_damage(available_damage)
average_damage_dealt = GameService.compute_average_damage_dealt(
games)
if average_damage_dealt is not None:
games_available_damage.append({
"damage_available":
available_damage,
"damage_dealt":
average_damage_dealt,
})
return games_available_damage
def get_database_data(filters_mage):
game_queryset = GameRepository.get_by_mage_list(filters_mage)
nemesis_list = GameRepository.get_nemesis_list(game_queryset)
nemesis_win_rates = []
for nemesis in nemesis_list:
games_by_nemesis_and_mage = GameRepository.filter_by_nemesis(game_queryset, nemesis.id)
win_rate = GameService.get_win_rate(games_by_nemesis_and_mage)
game_number = games_by_nemesis_and_mage.count()
if win_rate is not None:
nemesis_win_rates.append({
"nemesis_name": str(nemesis),
"nemesis_win_rate": win_rate,
"game_number": game_number,
})
nemesis_win_rates.sort(
key=lambda nemesis_win_rate: nemesis_win_rate["game_number"],
reverse=True
)
return nemesis_win_rates
def get_database_data(self):
mage_number_list = self.possible_mage_number
mage_number_win_rates = []
for mage_number in mage_number_list:
games = GameRepository.get_by_mage_number(mage_number)
win_rate = GameService.get_win_rate(games)
if win_rate is not None:
mage_number_win_rates.append({
"mage_number": mage_number,
"win_rate": win_rate,
"game_number": games.count()
})
return mage_number_win_rates
def get_database_data(filters_mage):
game_queryset = GameRepository.get_by_mage_list(filters_mage)
difficulty_list = NemesisRepository.get_unique_difficulties(
game_queryset)
nemesis_difficulty_win_rates = []
for difficulty in difficulty_list:
nemesis_list = NemesisRepository.get_by_difficulty(difficulty)
nemesis_list = NemesisRepository.transform_name_list_to_id(
nemesis_list)
games = GameRepository.filter_by_nemesis(game_queryset,
nemesis_list)
win_rate = GameService.get_win_rate(games)
game_number = games.count()
if win_rate is not None:
nemesis_difficulty_win_rates.append({
"nemesis_difficulty":
str(difficulty),
"win_rate":
win_rate,
"game_number":
game_number
})
return nemesis_difficulty_win_rates
def handle(self, *args, **options):
games = GameRepository.get_queryset()
for game in games:
print(game.remaining_nemesis_hp)
def update_profile_data(profile):
games = GameRepository.get_by_profile(profile)
profile.game_number = games.count()
victories = GameRepository.filter_by_victory(games)
profile.victory_number = victories.count()
profile.save()