def upload_players(self):
# Index 0 1 2 3 4 5 6 7 8 9
hdr = [
'name', 'country', 'type', 'tags', 'bid_order', 'matches', 'runs',
'catches', 'balls', 'wickets'
]
if self.data_list[0] != hdr:
return self.ERROR_INVALID_HEADER
Player.delete_all()
Bid.delete_all()
Player.init_batch()
for player_row in self.data_list[1:]:
player_row.reverse()
player = Player(player_row.pop().strip())
player.country = player_row.pop().strip()
country = Country(player.country)
player.rank = country.rank
player.color = country.color
player.bg_color = country.bg_color
player.country_code = country.code
player.type = player_row.pop().strip()
tags = [
tag.strip().lower() for tag in player_row.pop().split(';')
if len(tag) > 0
]
tags.append(player.country.lower())
tags.append(player.country_code.lower())
if player.type.lower() not in tags:
tags.append(player.type.lower())
player.tags = tags
try:
player.bid_order = int(player_row.pop())
except ValueError:
pass
try:
player.matches = int(player_row.pop())
except ValueError:
pass
try:
player.runs = int(player_row.pop())
except ValueError:
pass
try:
player.catches = int(player_row.pop())
except ValueError:
pass
try:
player.balls = int(player_row.pop())
except ValueError:
pass
try:
player.wickets = int(player_row.pop())
except ValueError:
pass
player.update_batch()
Player.commit_batch()
Game.init_game()
return self.SUCCESS
def upload_users(self):
# Index of columns 0 1 2 3 4
if self.data_list[0] != [
'username', 'name', 'password', 'color', 'bg_color'
]:
return self.ERROR_INVALID_HEADER
User.delete_all()
User.init_batch()
for user_row in self.data_list[1:]:
user = User(name=user_row[1].strip(), username=user_row[0].strip())
user.set_password(user_row[2])
user.color = user_row[3].strip().lower()
user.bg_color = user_row[4].strip().lower()
user.update_batch()
User.commit_batch()
Game.init_game()
return self.SUCCESS
def bid(command):
"""
Control bid status.\n
start - Start players for bid.\n
pause - Pause bidding.\n
resume - Resume bidding.\n
"""
env_banner()
game = Game.read()
if game is None:
game = Game.init_game()
command = command.lower().strip()
if command not in ['start', 'pause', 'resume']:
click.echo('Valid options are start, pause or resume.')
return
if game.user_count == 0 or game.player_count == 0:
click.echo('Init the game first by uploading player data.')
return
if game.player_to_bid == 0:
click.echo('Bidding is complete')
return
if command == 'start':
if game.bid_in_progress:
click.echo('Bid is already in progress.')
return
if game.player_to_bid != game.player_count:
click.echo('Bidding has already started. Use resume option.')
return
invite_bid()
click.echo('Bidding has been started.')
return
if command == 'pause':
if not game.bid_in_progress:
click.echo('Bid is NOT in progress.')
return
game.bid_in_progress = False
game.update()
click.echo('Bidding has been paused.')
return
if command == 'resume':
if game.bid_in_progress:
click.echo('Bid is already in progress.')
return
if game.player_to_bid == game.player_count:
click.echo('Bidding has not yet started. Use start option.')
return
game.bid_in_progress = True
game.update()
click.echo('Bidding has been resumed.')
def purchase_player_transaction(transaction, player, user=None, amount=0):
player_ref, player_snapshot = player.get_doc(transaction)
user_ref = None
user_snapshot = None
user_updates = None
if user:
user_ref, user_snapshot = user.get_doc(transaction)
if not user_snapshot:
return False
game = Game.read()
if not game:
game = Game.init_game()
game_ref, game_snapshot = game.get_doc(transaction)
if not player_snapshot or not game_snapshot:
return False
if user_snapshot:
player_updates = {
'status': player.PURCHASED,
'owner_username': user_snapshot.get('username'),
'owner': {
'name':
user_snapshot.get('name'),
'points':
user_snapshot.get('points') + player_snapshot.get('score'),
'color':
user_snapshot.get('color'),
'bg_color':
user_snapshot.get('bg_color'),
},
'price': amount,
}
user_updates = {
'balance': user_snapshot.get('balance') - amount,
'player_count': user_snapshot.get('player_count') + 1,
}
last_winner = user_snapshot.get('username').upper()
else:
player_updates = {'status': player.UNSOLD}
last_winner = 'Unsold'
amount = 0
player_value = Player.query_first(name=player_snapshot.get('name')).value
game_updates = {
'total_balance': game_snapshot.get('total_balance') - amount,
'player_in_bidding': None,
'player_to_bid': game_snapshot.get('player_to_bid') - 1,
'remaining_value': game_snapshot.get('remaining_value') - player_value,
'user_to_bid': 0,
'last_player': player_snapshot.get('name'),
'last_winner': last_winner,
'last_price': amount,
'bid_in_progress': False,
}
if user_updates:
transaction.update(user_ref, user_updates)
transaction.update(player_ref, player_updates)
transaction.update(game_ref, game_updates)
return True
def test_player_purchase(self):
# Setup user, player, game
sneha = User(name='Sneha Yadgire', username='******')
manisha = User(name='Manisha Auti', username='******')
rohit = Player('Rohit Sharma')
winner = {
'name': sneha.name,
'points': sneha.points,
'color': 'black',
'bg_color': 'white',
}
winner_username = sneha.username
players = ['p2', 'p3', 'p4', 'p5']
# Add them in db
sneha.create()
manisha.create()
rohit.create()
for _, name in enumerate(players):
player = Player(name)
player.create()
# Init game and test setup
game = Game.init_game()
# game.refresh()
self.assertEqual(len(players) + 1, game.player_count)
self.assertEqual(int(10000 * 2 / (len(players) + 1)),
game.avg_player_bid)
# Purchase Player
rohit.refresh()
sneha.refresh()
purchase_player(rohit, sneha, 2000)
# Refresh the game state after purchase
game.refresh()
rohit.refresh()
sneha.refresh()
# Test after purchase player
self.assertEqual(18000, game.total_balance)
self.assertEqual(len(players), game.player_to_bid)
self.assertFalse(game.player_in_bidding)
self.assertEqual(0, game.user_to_bid)
self.assertEqual(rohit.name, game.last_player)
self.assertEqual(sneha.username.upper(), game.last_winner)
self.assertEqual(2000, game.last_price)
self.assertEqual(8000, sneha.balance)
self.assertEqual(1, sneha.player_count)
self.assertEqual(Player.PURCHASED, rohit.status)
self.assertDictEqual(winner, rohit.owner)
self.assertEqual(winner_username, rohit.owner_username)
self.assertEqual(2000, rohit.price)
self.assertEqual(int(18000 / len(players)), game.avg_player_bid)
def test_game_setup(self):
# Setup user, player, game
sneha = User(name='Sneha Yadgire', username='******')
manisha = User(name='Manisha Auti', username='******')
rohit = Player('Rohit Sharma')
# Add them in db & refresh game status
sneha.create()
manisha.create()
rohit.create()
game = Game.init_game()
# Read game and test
self.assertEqual(game.player_count, 1)
self.assertEqual(game.user_count, 2)
self.assertEqual(game.avg_player_bid, User.INITIAL_BUDGET)
self.assertEqual(rohit.status, Player.AVAILABLE)
def accept_bid_transaction(transaction, bid, user, amount):
if amount != Bid.PASS and amount < 1:
return Bid.ERROR_INVALID_AMOUNT
if not bid:
return Bid.ERROR_SYSTEM
bid_ref, bid_snapshot = bid.get_doc(transaction)
game = Game.read()
if not game:
game = Game.init_game()
game_ref, game_snapshot = game.get_doc(transaction)
# Validate (Does NOT validate if the user exists in the db)
if not bid_snapshot or not user or not user.username:
return Bid.ERROR_SYSTEM
if user.username not in game_snapshot.get('users_to_bid'):
return Bid.ERROR_ALREADY_BID
if user.balance < amount:
return Bid.ERROR_NO_BALANCE
player = Player.query_first(name=bid.player_name)
if not player:
return Bid.ERROR_PLAYER_NOT_FOUND
if player.status != Player.BIDDING:
return Bid.ERROR_PLAYER_NOT_INVITED_TO_BID
user_bid = {
'username': user.username,
'amount': amount,
}
bid_list = [user_bid]
if bid_snapshot.get('bid_map'):
bid_list = bid_snapshot.get('bid_map')
bid_list.append(user_bid)
user_list = game_snapshot.get('users_to_bid')
if user_list:
user_list.remove(user.username)
bid_updates = {
'bid_map': bid_list,
}
game_updates = {
'user_to_bid': game_snapshot.get('user_to_bid') - 1,
'users_to_bid': user_list,
}
transaction.update(bid_ref, bid_updates)
transaction.update(game_ref, game_updates)
return Bid.SUCCESS
def invite_bid_transaction(transaction, player):
player_ref, player_snapshot = player.get_doc(transaction)
game = Game.read()
if not game:
game = Game.init_game()
game_ref, game_snapshot = game.get_doc(transaction)
# Validate
if not player_snapshot or player_snapshot.get(
'status') != Player.AVAILABLE:
return Bid.ERROR_PLAYER_NOT_AVAILABLE
if game_snapshot.get('bid_in_progress'):
return Bid.ERROR_BID_IN_PROGRESS
bid = Bid(player_snapshot.get('name'))
# Creation not in transaction is fine since it will only create the bid once
bid = bid.create()
player_updates = {'status': Player.BIDDING}
game_updates = {
'bid_in_progress': True,
'user_to_bid': game_snapshot.get('user_count'),
'player_in_bidding': player_snapshot.get('name'),
'users_to_bid': [user.username for user in User.get_all()]
}
# Auto bid for zero balance
zero_balance_users = User.query(balance=0)
if zero_balance_users:
bid_ref, bid_snapshot = bid.get_doc(transaction)
bid_updates = {
'bid_map': bid_snapshot.get('bid_map'),
}
for user in zero_balance_users:
zero_bid = {
'username': user.username,
'amount': Bid.NO_BALANCE,
}
bid_updates['bid_map'].append(zero_bid),
game_updates['user_to_bid'] -= 1
game_updates['users_to_bid'].remove(user.username)
transaction.update(bid_ref, bid_updates)
transaction.update(player_ref, player_updates)
transaction.update(game_ref, game_updates)
return Bid.SUCCESS
def test_bid(self):
# Setup players, users and game in db
player_list = [
{
'name': 'Rohit Sharma',
'bid_order': 2
},
{
'name': 'Shikhar Dhawan',
'bid_order': 4
},
{
'name': 'Virat Kohli',
'bid_order': 1
},
{
'name': 'Hardik Pandya',
'bid_order': 3
},
{
'name': 'Jasprit Bumrah',
'bid_order': 5
},
]
user_list = [
{
'username': '******',
'name': 'Nayan'
},
{
'username': '******',
'name': 'Pranay'
},
{
'username': '******',
'name': 'Shraddha'
},
{
'username': '******',
'name': 'Raj'
},
]
for player in player_list:
Player.from_dict(player).create()
for user in user_list:
User.from_dict(user).create()
game = Game.init_game()
# Invite bid and check
bid = invite_bid()
game.refresh()
self.assertIsInstance(bid, Bid)
self.assertEqual('Virat Kohli', game.player_in_bidding)
self.assertEqual(4, game.user_to_bid)
self.assertEqual(5, game.player_to_bid)
self.assertEqual(Player.BIDDING,
Player.query_first(name='Virat Kohli').status)
self.assertTrue(game.bid_in_progress)
self.assertEqual(1, bid.bid_order)
# One Bid on 1st player
bid_result = accept_bid(bid, User.query_first(username='******'), 1500)
bid.refresh()
game.refresh()
self.assertEqual(Bid.SUCCESS, bid_result)
self.assertNotIn('nz', game.users_to_bid)
self.assertTrue(bid.has_bid('nz'))
self.assertEqual(3, game.user_to_bid)
self.assertIn({'username': '******', 'amount': 1500}, bid.bid_map)
# Two more bid on 1st player
bid_result = accept_bid(bid, User.query_first(username='******'), 1200)
bid.refresh()
game.refresh()
self.assertEqual(Bid.SUCCESS, bid_result)
bid_result = accept_bid(bid, User.query_first(username='******'), 1550)
bid.refresh()
game.refresh()
self.assertEqual(Bid.SUCCESS, bid_result)
self.assertIn('sa', game.users_to_bid)
self.assertEqual(1, game.user_to_bid)
self.assertFalse(bid.is_bid_complete(game.user_count))
self.assertEqual(Bid.SUCCESS, bid_result)
self.assertFalse(bid.has_bid('sa'))
# Last player and check winner
bid_result = accept_bid(bid, User.query_first(username='******'), 1350)
bid.refresh()
game.refresh()
self.assertEqual('RG', game.last_winner)
self.assertEqual('Virat Kohli', game.last_player)
self.assertEqual(1550, game.last_price)
self.assertEqual(Player.PURCHASED,
Player.query_first(name='Virat Kohli').status)
self.assertEqual('rg',
Player.query_first(name='Virat Kohli').owner_username)
self.assertEqual('rg', bid.winner)
self.assertEqual(1550, bid.winning_price)
# Check if the next player is properly invited for bid
bid = bid_result
self.assertIsInstance(bid, Bid)
self.assertEqual('Rohit Sharma', game.player_in_bidding)
self.assertEqual(4, game.user_to_bid)
self.assertEqual(4, game.player_to_bid)
self.assertEqual(Player.BIDDING,
Player.query_first(name='Rohit Sharma').status)
self.assertTrue(game.bid_in_progress)
self.assertEqual(2, bid.bid_order)
# Pass the player
bid_result = accept_bid(bid, User.query_first(username='******'), Bid.PASS)
game.refresh()
bid.refresh()
self.assertEqual(Bid.SUCCESS, bid_result)
bid_result = accept_bid(bid, User.query_first(username='******'))
game.refresh()
bid.refresh()
self.assertEqual(Bid.SUCCESS, bid_result)
bid_result = accept_bid(bid, User.query_first(username='******'), Bid.PASS)
game.refresh()
bid.refresh()
self.assertEqual(Bid.SUCCESS, bid_result)
self.assertEqual(1, game.user_to_bid)
bid_result = accept_bid(bid, User.query_first(username='******'))
game.refresh()
bid.refresh()
self.assertIsInstance(bid_result, Bid)
self.assertEqual('Unsold', game.last_winner)
self.assertEqual('Rohit Sharma', game.last_player)
self.assertEqual(0, game.last_price)
self.assertEqual(Player.UNSOLD,
Player.query_first(name='Rohit Sharma').status)
self.assertIsNone(
Player.query_first(name='Rohit Sharma').owner_username)
self.assertIsNone(bid.winner)
self.assertEqual(0, bid.winning_price)
# Check next player
bid = bid_result
self.assertEqual('Hardik Pandya', game.player_in_bidding)
self.assertEqual(4, game.user_to_bid)
self.assertEqual(3, game.player_to_bid)
self.assertEqual(Player.BIDDING,
Player.query_first(name='Hardik Pandya').status)
self.assertTrue(game.bid_in_progress)
self.assertEqual(3, bid.bid_order)
# Check accept bid errors
self.assertEqual(Bid.ERROR_INVALID_AMOUNT, accept_bid(bid, None, 0))
self.assertEqual(Bid.ERROR_SYSTEM, accept_bid(bid, None))
test_user = User(name='Nayan', username='******')
test_user.username = None
self.assertEqual(Bid.ERROR_SYSTEM, accept_bid(bid, test_user))
test_user.username = '******'
self.assertEqual(Bid.ERROR_SYSTEM, accept_bid(None, test_user))
test_bid = Bid('No Player')
self.assertEqual(Bid.ERROR_SYSTEM, accept_bid(test_bid, test_user))
test_bid = Bid.read(bid.doc_id)
test_bid.player_name = 'Invalid Player'
self.assertEqual(Bid.ERROR_PLAYER_NOT_FOUND,
accept_bid(test_bid, test_user))
test_bid.player_name = 'Rohit Sharma'
self.assertEqual(Bid.ERROR_PLAYER_NOT_INVITED_TO_BID,
accept_bid(test_bid, test_user))
self.assertEqual(Bid.ERROR_NO_BALANCE,
accept_bid(bid, test_user, User.INITIAL_BUDGET + 100))
self.assertEqual(Bid.SUCCESS, accept_bid(bid, test_user))
self.assertEqual(Bid.ERROR_ALREADY_BID, accept_bid(bid, test_user))
# Let other players bid
bid_result = accept_bid(bid, User.query_first(username='******'), 2000)
self.assertEqual(Bid.SUCCESS, bid_result)
bid_result = accept_bid(bid, User.query_first(username='******'), 2100)
self.assertEqual(Bid.SUCCESS, bid_result)
bid_result = accept_bid(bid, User.query_first(username='******'), 10000)
self.assertIsInstance(bid_result, Bid)
self.assertEqual(
'sa',
Player.query_first(name=bid.player_name).owner_username)
# Bid for next player and check the auto zero bid for 'sa'
bid = bid_result
bid_result = accept_bid(bid, User.query_first(username='******'), 2000)
self.assertEqual(Bid.SUCCESS, bid_result)
bid_result = accept_bid(bid, User.query_first(username='******'), 2600)
self.assertEqual(Bid.SUCCESS, bid_result)
bid_result = accept_bid(bid, User.query_first(username='******'), 2700)
self.assertIsInstance(bid_result, Bid)
self.assertEqual(
'rg',
Player.query_first(name=bid.player_name).owner_username)
self.assertEqual(2, User.query_first(username='******').player_count)
self.assertTrue(bid.has_bid('sa'))
self.assertEqual(Bid.NO_BALANCE, [
bd['amount'] for bd in bid.bid_map if bd['username'] == 'sa'
][0])
# Bid for next player and check for a tie
bid = bid_result
bid_result = accept_bid(bid, User.query_first(username='******'), 5000)
self.assertEqual(Bid.SUCCESS, bid_result)
bid_result = accept_bid(bid, User.query_first(username='******'), 5000)
self.assertEqual(Bid.SUCCESS, bid_result)
bid_result = accept_bid(bid, User.query_first(username='******'), 5000)
self.assertEqual(Bid.ERROR_NO_MORE_PLAYERS, bid_result)
self.assertIn(
Player.query_first(name=bid.player_name).owner_username,
['nz', 'pp', 'rg'])
game.refresh()
self.assertEqual(0, game.player_to_bid)
self.assertIsNone(game.player_in_bidding)
self.assertFalse(game.bid_in_progress)
self.assertEqual(0, game.user_to_bid)
# Check bids view
bids = bids_view()
self.assertEqual(5, len(bids))
self.assertEqual('Jasprit Bumrah', bids[0].player_name)
test_usernames = ['nz', 'pp', 'rg', 'sa']
db_usernames = [bd['username'] for bd in bids[0].bid_map]
self.assertListEqual(test_usernames, db_usernames)
# Check paginated bids view
page = bids_view(3)
page = bids_view(page.per_page, end=page.current_end.doc_id)
self.assertEqual('Rohit Sharma', page.items[0].player_name)
db_usernames = [bd['username'] for bd in page.items[0].bid_map]
self.assertListEqual(test_usernames, db_usernames)
def test_sorted_player_view(self):
# Setup players and users in db
player_list = [
{
'name': 'Rohit Sharma',
'score': 60.5
},
{
'name': 'Shikhar Dhawan',
'score': 100.0
},
{
'name': 'Virat Kohli',
'score': 245.5
},
{
'name': 'Hardik Pandya',
'score': 251
},
{
'name': 'Jasprit Bumrah',
'score': 151
},
]
user_list = [
{
'username': '******',
'name': 'Nayan'
},
{
'username': '******',
'name': 'Pranay'
},
]
test_player_list = [
{
'name': 'Hardik Pandya',
'score': 251,
'owner_username': '******',
'owner': {
'name': 'Pranay',
'points': 657.0,
'color': 'black',
'bg_color': 'white'
},
'status': Player.PURCHASED,
'price': 350,
},
{
'name': 'Virat Kohli',
'score': 245.5,
'owner_username': '******',
'owner': {
'name': 'Pranay',
'points': 657.0,
'color': 'black',
'bg_color': 'white'
},
'status': Player.PURCHASED,
'price': 350,
},
{
'name': 'Shikhar Dhawan',
'score': 100.0,
'owner_username': '******',
'owner': {
'name': 'Pranay',
'points': 657.0,
'color': 'black',
'bg_color': 'white'
},
'status': Player.PURCHASED,
'price': 350,
},
{
'name': 'Rohit Sharma',
'score': 60.5,
'owner_username': '******',
'owner': {
'name': 'Pranay',
'points': 657.0,
'color': 'black',
'bg_color': 'white'
},
'status': Player.PURCHASED,
'price': 350,
},
]
test_players = list()
for player in player_list:
Player.from_dict(player).create()
for user in user_list:
User.from_dict(user).create()
for player in test_player_list:
test_players.append(Player.from_dict(player))
# Purchase players
nayan = User.read('nz')
pranay = User.read('pp')
players = Player.get_all()
game = Game.init_game()
for player in players:
if player.name == 'Jasprit Bumrah':
purchase_player(player, nayan, 300)
else:
purchase_player(player, pranay, 350)
# Refresh & Check purchase players
game.refresh()
nayan.refresh()
pranay.refresh()
self.assertEqual(0, game.user_to_bid)
self.assertEqual(1, nayan.player_count)
self.assertEqual(4, pranay.player_count)
# Get pranay player view and check
data = purchased_players_view(pranay.username)
for index, db_player in enumerate(data['players']):
self.assertDictEqual(test_players[index].to_dict(),
db_player.to_dict())
self.assertEqual(657, data['summary']['score'])
self.assertEqual(1400, data['summary']['price'])
