def create_card(data, activity_id):
card = Card(github_raw_data=data["github_raw_data"],
name=data["name"],
gems=data["gems"],
order=data["order"],
filename=data["filename"],
activity_id=activity_id)
github_data = requests.get(data["github_raw_data"])
card.content = update_card_images(github_data.text, data["filename"])
return card
def test_instances_differences(self):
card1 = Card(name="Card 1",
key='card-1',
arena=12,
elixir=42,
max_level=1)
card2 = Card(name="Card 2", key='card-2', elixir=12, max_level=12)
diff = int_difference_instances(card1, card2, ('max_level', ))
self.assertIn('elixir', diff)
self.assertNotIn('arena', diff)
self.assertNotIn('key', diff)
self.assertEqual(diff['elixir'], 30)
self.assertNotIn('max_level', diff)
def read_player_stats(self, db_player, player=None):
"""
Refresh a single user's profile
:param Player db_player: a player from database
:param Box player: data to be read
:return: False on APIError
"""
if player is None:
player = self.client.get_player(db_player.tag)
if not db_player.name:
db_player, _ = Player.objects.get_or_create(tag=player.tag[1:], defaults={'refresh': db_player.refresh})
db_player.name = player.name
query_fields = {
'player': db_player,
'level': player.exp_level,
'total_donations': player.total_donations,
'highest_trophies': player.best_trophies,
'current_trophies': player.trophies,
'challenge_cards_won': player.challenge_cards_won,
'tourney_cards_won': player.tournament_cards_won,
'cards_found': len(player.cards),
'total_games': player.battle_count,
'arena': int(str(player.arena.id)[2:]),
'tournament_games': player.tournament_battle_count,
'defaults': {'timestamp': self.now}
}
db_player_stats, _ = PlayerStatsHistory.create_or_get(**query_fields)
db_player_stats.favorite_card = Card.instance_from_data(player.current_favourite_card).key
db_player_stats.win_3_crowns = player.three_crown_wins
db_player_stats.draws = player.battle_count - player.wins - player.losses
db_player_stats.losses = player.losses
db_player_stats.wins = player.wins
db_player_stats.clan_cards_collected = player.clan_cards_collected
db_player_stats.war_day_wins = player.war_day_wins
db_player_stats.last_refresh = self.now
db_player_stats.save()
# Player seasons (current & best seasons skipped)
if player.league_statistics is not None and 'previousSeason' in player.league_statistics.keys():
prev_season = player.league_statistics.previous_season
db_season, _ = LeagueSeason.objects.get_or_create(
identifier=prev_season.id,
defaults={'timestamp': self.now}
)
PlayerSeason.objects.get_or_create(
player=db_player,
season=db_season,
defaults={
'ending_rank': prev_season.rank if 'rank' in prev_season.keys() else None,
'highest': prev_season.best_trophies if 'bestTrophies' in prev_season.keys() else prev_season.trophies,
'ending': prev_season.trophies
}
)
return True
def test_card_parsing(self):
"""Test the parsing of a single card"""
data = Box(self.card, camel_killer_box=True)
card = Card.instance_from_data(data)
# Test required fields
self.assertEqual(card.name, data.name)
self.assertEqual(card.key, data.key)
self.assertEqual(card.image, data.icon_urls.medium)
def store_battle_players(db_player, team, players, save_decks=True):
i = 0
decks = [[], []]
for p in players:
if p.tag[1:] == db_player.tag:
db_p = db_player
else:
db_p, created = Player.objects.get_or_create(tag=p.tag[1:], defaults={'name': p.name})
team.add(db_p)
if save_decks:
for card in p.deck:
c = Card.instance_from_data(card)
decks[i].append(c)
i += 1
return decks
def get_game_data(self):
ret = super(BlackJackTable, self).get_game_data()
ret['game_state'] = self.game_state
dealer_cards = self.current_round and self.current_round.dealers_hand.get_cards() or []
dealer_up_cards = []
if self.game_state == consts.GAME_STATE_PLAYING:
dealer_up_cards.append(Card.get_face_down())
for card in dealer_cards[1:]:
dealer_up_cards.append(card)
ret['dealer_up_cards'] = dealer_up_cards
all_hands = BlackJackHand.objects.filter(round=self.current_round, dealers_hand=False)
for hand in all_hands:
player = [s for s in ret['seats'] if s['player_id'] == hand.player_id][0]
player['cards'] = hand.get_cards()
player['available_actions'] = hand.get_available_actions()
return ret
def read_player_cards(self, db_player, cards=None):
"""
Read cards from a player fetched by the client
:param Player db_player: the player we are reading
:param list cards: the data to be read
:return: None
"""
if cards is None:
cards = self.client.get_player(db_player.tag).cards
if not cards:
return
for card in cards:
db_card = Card.instance_from_data(card)
db_pcl, created = PlayerCardLevel.create_or_get(player=db_player, card=db_card)
if db_pcl.count != card.count:
db_pcl.count = card.count
db_pcl.level = card.level
db_pcl.count = card.count
db_pcl.star_level = card.star_level if 'starLevel' in card.keys() else 0
db_pcl.save()
def add_card(self, card):
cards = self.get_cards()
cards.append(card)
self.set_cards(cards)
if self.can_split:
actions = self.get_available_actions()
actions.append('split')
self.set_available_actions(actions)
self.save()
#augment the card data for client
if self.dealers_hand:
card['dealt_to'] = 'dealer'
else:
if self.split_from.all().count():
card['split_card'] = True
player_id = self.player_id
card['dealt_to'] = player_id
if (self.dealers_hand and self.num_cards == 1):
card.update(Card.get_face_down())
client = Client(data=card, table_id=self.round.table_id, action='deal_card')
client.notify()
def test_get_key_from_name(self):
self.assertEquals(Card.key_from_name('X-Bow'), 'x-bow')
self.assertEquals(Card.key_from_name('P.E.K.K.A'), 'pekka')
self.assertEquals(Card.key_from_name('Giant Skeleton'),
'giant-skeleton')
