def create_players():
try:
data = request.get_json() or {}
player_one = Player()
player_two = Player()
player_one.username = data['playerOneName']
player_two.username = data['playerTwoName']
result_one = player_one.add_to_game(data['gameId'])
result_two = player_two.add_to_game(data['gameId'])
if result_one == "Game is Full" or result_two == "Game is Full":
return jsonify(
{"error": "Cannot Add Player To An Already Full Game"})
if result_one != "Game is Full" and result_two != "Game is Full":
db.session.add(player_one)
db.session.add(player_two)
db.session.commit()
response = jsonify({
"playerOneId": player_one.id,
"playerOneName": player_one.username,
"playerTwoId": player_two.id,
"playerTwoName": player_two.username
})
response.status_code = 201
return response
except Exception as e:
response = jsonify({"error": str(e)})
response.status_code = 500
return response
def post(self):
gameroom = GameRoom.objects(
waiting=True).order_by("created_at").first()
player = Player(name=current_user.username)
# join existing room
if gameroom:
gameroom.waiting = False
gameroom.members.append(player)
gameroom.save()
# create a new room
else:
gameroom = GameRoom()
gameroom.members.append(player)
gameroom.save()
g_id = gameroom.id
time.sleep(10)
gameroom = GameRoom.objects(id=g_id).first()
if gameroom.waiting:
gameroom.hasBot = True
gameroom.waiting = False
bot = list(
User.objects(isBot=True).aggregate([{
'$sample': {
"size": 1
}
}]))[0]
player = Player(name=bot['username'])
gameroom.botName = bot['username']
gameroom.members.append(player)
gameroom.save()
gameroom.save()
return make_response(jsonify(gameroom), 201)
def __setup_test_data(self):
# setup
self.p1 = Player(
account_id=1,
steam_id="1",
personaname="p1",
name="player1",
avatar="p1.jpg"
)
self.ms1 = MatchScore(
week_score=0.5,
month_score=0.6,
year_score=0.3,
overall_count=10,
overall_score=0.5313,
player=self.p1
)
self.p2 = Player(
account_id=2,
steam_id="2",
personaname="p2",
name="player2",
avatar="p2.jpg"
)
self.ms2 = MatchScore(
week_score=0.6,
month_score=0.5,
year_score=0.2,
overall_count=100,
overall_score=0.4313,
player=self.p2
)
self.h1 = Hero(
hero_id=1,
name='h1',
localized_name='hero1',
primary_attr='magic',
attack_type='fire',
roles='a,b,c',
legs=0
)
self.hs1 = HeroScore(
hero_score_id=1,
rank_score=0.1,
last_played_score=0.1,
win_score=0.1,
overall_score=0.78,
score_date=date.today(),
player_id=self.p1.account_id,
hero_id=self.h1.hero_id,
player=self.p1,
hero=self.h1
)
db.session.add(self.ms1)
db.session.add(self.ms2)
db.session.add(self.hs1)
db.session.commit()
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 get_team():
"""
Initializes the squad: the list of players in the order they are
expected to bat.
Uses the Player model to create each batsman with their given
scoring probabilities.
"""
batsmen_list = [
Player('Kirat Boli', {
'0': 5,
'1': 30,
'2': 25,
'3': 10,
'4': 15,
'5': 1,
'6': 9,
'OUT': 5,
}),
Player('N.S. Nodhi', {
'0': 10,
'1': 40,
'2': 20,
'3': 5,
'4': 10,
'5': 1,
'6': 4,
'OUT': 10,
}),
Player('R Rumrah', {
'0': 20,
'1': 30,
'2': 15,
'3': 5,
'4': 5,
'5': 1,
'6': 4,
'OUT': 20,
}),
Player('Shashi Henra', {
'0': 30,
'1': 25,
'2': 5,
'3': 0,
'4': 5,
'5': 1,
'6': 4,
'OUT': 30,
})
]
return batsmen_list
def save_player(session, item_dict):
"""Save player to database"""
player = Player()
player.id = item_dict['player_id']
player.name = item_dict['player_name']
session.add(player)
return player
def index():
if request.method == 'POST':
nickname = request.form.get('nickname')
password = request.form.get('password')
if password == '':
password = None
if nickname == '':
background = random.choice(['1', '2', '3'])
return render_template('index.html', background=url_for('static', filename='backgrounds/{}.jpg'.format(background)), errors=True)
g = Game(password=password, card=BlackCards.query.order_by(func.random()).first())
db.session.add(g)
db.session.commit()
p = Player(nickname=nickname, game=g, uuid=uuid.uuid4().hex)
db.session.add(p)
db.session.commit()
session['player'] = p.id
return redirect( url_for('game', id=g.id) )
elif request.method == 'GET':
background = random.choice(['1', '2', '3'])
return render_template('index.html', background=url_for('static', filename='backgrounds/{}.jpg'.format(background)))
def populate_player_hero_scores_from_json(hero_ranking_json, hero_match_json,
heroes_json, player_json, player_id):
hs_dict = {}
for h in json.loads(heroes_json):
hs_dict[h['id']] = h
app.logger.info("heroes dict: {}".format(hs_dict))
hm_dict = {}
max_win = -1
max_last_played = -1
for hm in json.loads(hero_match_json):
# NOTE: in player hero API, hero_id is string type, wired! :(
hm_dict[int(hm['hero_id'])] = hm
if max_win < hm['win']:
max_win = hm['win']
if max_last_played < hm['last_played']:
max_last_played = hm['last_played']
app.logger.info("hero match dict: {}".format(hm_dict))
hr_dict = {}
for hr in json.loads(hero_ranking_json):
hr_dict[hr['hero_id']] = hr
app.logger.info("hero rank dict: {}".format(hm_dict))
# TODO: player might not present when another client is accessing, need a lock here
player = Player.query.filter(Player.account_id == player_id).first()
if player is None:
p_dict = json.loads(player_json)
player = Player(account_id=p_dict['profile']['account_id'],
steam_id=p_dict['profile']['steamid'],
personaname=p_dict['profile']['personaname'],
name=p_dict['profile']['name'],
avatar=p_dict['profile']['avatar'])
db.session.add(player)
db.session.commit()
for hero_id in hs_dict.keys():
hero = Hero.query.filter(Hero.hero_id == hero_id).first()
if hero is None:
hero = Hero(hero_id=hero_id,
name=hs_dict[hero_id]['name'],
localized_name=hs_dict[hero_id]['localized_name'],
primary_attr=hs_dict[hero_id]['primary_attr'],
attack_type=hs_dict[hero_id]['attack_type'],
roles=",".join(hs_dict[hero_id]['roles']),
legs=hs_dict[hero_id]['legs'])
db.session.add(hero)
db.session.commit()
hero_score = HeroScore(player=player, hero=hero)
if hero_id not in hm_dict:
hero_score.last_played_score = 0.0
hero_score.win_score = 0.0
else:
last_played = hm_dict[hero_id]['last_played']
hero_score.last_played_score = float(last_played) / max_last_played
win = hm_dict[hero_id]['win']
hero_score.win_score = float(win) / max_win
if hero_id not in hr_dict:
hero_score.rank_score = 0.0
else:
hero_score.rank_score = hr_dict[hero_id]['percent_rank']
hero_score.overall_score = hero_score.get_overall_score()
db.session.add(hero_score)
db.session.commit()
def add_player(new_player_name):
pass
existing_names = [
p.player_name
for p in Player.query.filter(Player.player_name == new_player_name)
]
if new_player_name in existing_names:
pass
return jsonify({'player name': 'already exists on Player database'})
else:
pass
db.session.add(
Player(
avatar_url=
'https://raw.githubusercontent.com/attila5287/regropoly/master/app/static/profile_pics/attila.jpg',
player_name=new_player_name,
avlb_funds=10000000,
high_worth=10000000,
low_worth=10000000,
rtn_on_inv=0,
num_of_inv=0))
q_added = Player.query.filter(Player.player_name == new_player_name)
d = [{c.name: getattr(q, c.name)
for c in q.__table__.columns} for q in q_added]
db.session.commit()
return jsonify(d[0])
def create_player():
data = request.get_json()
try:
new_player = Player(
first_name=data["first_name"],
last_name=data["last_name"],
user_id=current_user.id,
height=data["height"],
weight=data["weight"],
position=data["position"],
address=data["address"],
phone_number=data["phone_number"],
email=data["email"],
team_name=data["team_name"],
team_city=data["team_city"],
team_state=data["team_state"],
bats=data["bats"],
throws=data["throws"],
dob=data["dob"],
hot_list=data["hotList"]
)
db.session.add(new_player)
db.session.commit()
return jsonify({'player': new_player.to_dict()})
except:
return jsonify({'errors': True})
def add_player():
"""
Requires user authentication (username:password) in order to access
function.
If authenticated:
Accepts player representation in JSON format from client, provided in
request body. If mandatory fields (player_name) are not present, returns
a bad_request error. Otherwise, creates a player object and adds it to
database. Returns the newly created player representation, with 201
status code and a Location header with the URL of the new resource.
If not authenticated:
Returns a 401 error response.
"""
data = request.get_json() or {}
if 'player_name' not in data:
return bad_request('Must include player_name field')
player = Player()
player.from_dict(data)
db.session.add(player)
db.session.commit()
response = jsonify(player.to_dict())
response.status_code = 201
response.headers['Location'] = url_for('api.get_player_id', id=player.id)
return response
def addplayer():
form = AddPlayerForm()
players = Player.query.all()
if form.validate_on_submit() and 'submit' in request.form:
player = Player(firstname=form.firstname.data,
lastname=form.lastname.data)
db.session.add(player)
db.session.commit()
# If more than 2 players automatically create teams for the newly added player
if len(Player.query.all()) > 1:
latest_player = Player.query.order_by(Player.id.desc()).first()
all_players = Player.query.all()
created_teams = create_teams(latest_player.id, all_players)
flash(
prepare_flash_message(
"New player was added and following teams were created: ",
created_teams))
else:
flash('New player was added')
return redirect(url_for('addplayer'))
return render_template('addplayer.html',
title='Add new player',
form=form,
players=players)
def addPlayer(data):
message = 'Прости, но ты уже есть в списке игроков.\n\n'
user_id = data['from_id']
player = Player.query.filter_by(user_id=user_id).first()
if not player:
# получаем имя, так как оно последнее и без пробелов
name = data['text'].split()[-1]
if check_name(name):
message = 'Такое имя уже есть в списке.\n\n'
return message, ''
date = datetime.datetime.today() + datetime.timedelta(hours=3)
player = Player(user_id=user_id, name=name, date=date)
db.session.add(player)
db.session.commit()
message = 'Я добавил тебя в таблицу.\n\n'
players = Player.query.all()
for player in players:
message += player.name + " - " + player.date.strftime(
"%d/%m/%Y") + "\n"
return message, ''
def bootstrap():
with open('bootstrap.csv') as csvfile:
players = csv.reader(csvfile)
for p in players:
np = Player(name=p[0], wins=p[1], kills=p[2], deaths=p[3])
db.session.add(np)
db.session.commit()
def __store_to_db(self, content):
try:
Player.objects.get(internal_identifier=content['internal_identifier'])
except Player.DoesNotExist:
player_to_add = Player(internal_identifier=content['internal_identifier'],
internal_person_identifier=content['internal_person_identifier'])
player_to_add.save()
def create(self):
try:
entry_params = self.request.json
player_validator = PlayerValidator(entry_params)
player_validator.validate()
if player_validator.is_valid():
player = Player(name=entry_params['name'],
gold=0,
attack_strength=70,
hit_points=100,
luck=10,
score=0)
db.session.add(player)
db.session.commit()
redis.connection.zadd('leaderboard', {player.id: player.score})
return '', 201
else:
return jsonify(player_validator.errors), 422
except Exception as err:
# TODO: logging service
print(err)
return 'Internal Server Error', 500
def test_to_dict_function(app):
"""Test Player's to_dict() function."""
app = app(TestingConfig)
test_model_to_insert = Player(
player_name="Test Name",
player_image="testname.jpg",
position="PG",
first_nba_season=2019,
field_goal_made=100.3,
field_goal_attempted=100.3,
field_goal_pct=33.3,
three_pt_made=100.3,
three_pt_attempted=100.3,
three_pt_pct=33.3,
free_throw_made=100.3,
free_throw_attempted=100.3,
free_throw_pct=33.3,
true_stg_pct=33.3,
points=33.3,
off_reb=33.3,
def_reb=33.3,
tot_reb=33.3,
assists=33.3,
steals=33.3,
blocks=33.3,
turnovers=33.3,
)
db.session.add(test_model_to_insert)
db.session.commit()
data = test_model_to_insert.to_dict()
print(data)
assert data['id'] == 1
assert data['player_name'] == 'Test Name'
assert data['player_image'] == 'testname.jpg'
assert data['positions'] == 'PG'
assert data['first_nba_season'] == 2019
assert data['shooting']['field_goal_made'] == 100.3
assert data['shooting']['field_goal_attempted'] == 100.3
assert data['shooting']['field_goal_pct'] == 33.3
assert data['shooting']['three_pt_made'] == 100.3
assert data['shooting']['three_pt_attempted'] == 100.3
assert data['shooting']['three_pt_pct'] == 33.3
assert data['shooting']['free_throw_made'] == 100.3
assert data['shooting']['free_throw_attempted'] == 100.3
assert data['shooting']['free_throw_pct'] == 33.3
assert data['shooting']['true_stg_pct'] == 33.3
assert data['shooting']['points'] == 33.3
assert data['off_reb'] == 33.3
assert data['def_reb'] == 33.3
assert data['tot_reb'] == 33.3
assert data['assists'] == 33.3
assert data['steals'] == 33.3
assert data['blocks'] == 33.3
assert data['turnovers'] == 33.3
assert data['_links']['self'] == url_for('api.get_player_id',
id=data['id'])
def seed_db():
client = StrictRedis(host=REDIS_HOST, port=REDIS_PORT, db=REDIS_DB)
client.flushdb()
players = distribute_players()
for player in players:
tasks = generate_tasks()
redis_player = Player(row=player[0], column=player[1], tasks=tasks)
redis_player.save()
def get_player_id(request):
player_id = request.session.get('player_id')
if player_id is None:
player = Player()
player.save()
player_id = player.id
request.session['player_id'] = player_id
return player_id
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 update_players(game):
"""Update players to database"""
supremacy = Supremacy(game.game_id, game.game_host)
result = supremacy.players()
result = result["players"]
for player_id in result:
player_data = result[player_id]
if "playerID" in player_data:
player_id = int(player_data["playerID"])
if player_id > 0:
player = Player.query.filter(
and_(Player.game_id == game.id,
Player.player_id == player_id)).first()
if player is None:
player = Player()
player.start_day = game.last_day
player.nation_name = player_data["nationName"]
player.primary_color = player_data["primaryColor"]
player.secondary_color = player_data["secondaryColor"]
player.game_id = game.id
player.player_id = player_id
if "userName" in player_data and not player.user_id:
user = User.query.filter(
User.name == player_data["userName"]).first()
if user is None:
user = User()
user.site_id = player_data["siteUserID"]
user.name = player_data["userName"]
db.session.add(user)
db.session.commit()
player.user_id = user.id
player.title = player_data["title"]
player.name = player_data["name"]
player.flag_image_id = player_data["flagImageID"]
player.player_image_id = player_data["playerImageID"]
player.computer_player = player_data["computerPlayer"]
player.native_computer = player_data["nativeComputer"]
player.defeated = player_data["defeated"]
if player_data["lastLogin"] != 0:
player.last_login = datetime.fromtimestamp(
player_data["lastLogin"] / 1000)
db.session.add(player)
db.session.commit()
def test_player_db_create(app):
"""Test Player table creation."""
app = app(TestingConfig)
test_model_to_insert = Player(player_name='Test Name')
db.session.add(test_model_to_insert)
db.session.commit()
assert db.session.query(Player).one()
def new_player():
form = NewPlayerForm()
if form.validate_on_submit():
player = Player(name=form.name.data)
db.session.add(player)
db.session.commit()
flash('Player {} successfully created'.format(player.name),
'form-success')
return render_template('admin/new_player.html', form=form)
def test_player_db_repr(app):
"""Test Player object representation."""
app = app(TestingConfig)
test_model_to_insert = Player(player_name='Test Name')
db.session.add(test_model_to_insert)
db.session.commit()
assert str(db.session.query(Player).first()) == '<Player: Test Name>'
def _populate_db(self):
count = 200
all_users = Player.objects.all()
for user in all_users:
print(user)
print(len(all_users))
new_user = Player(username="******", surname="surname12")
new_user.save()
def get_player(session, player_id, player_name):
"""Get player from database"""
player = session.query(Player).get(player_id)
if player is None:
player = Player()
player.id = player_id
player.name = player_name
session.add(player)
session.commit()
return player
def signup():
form = SignUpForm();
if form.validate_on_submit():
player = Player(firstname=form.firstname.data, lastname=form.lastname.data, phone=form.phone.data, email=form.email.data,
plz=form.plz.data, city=form.city.data, jersey_size=form.jersey_size.data, jersey_print=form.jersey_print.data)
flash("Neue Anmeldung: " + str(player))
db.session.add(player)
db.session.commit()
return redirect(url_for('index'))
return render_template('signup.html', title='Anmelden', form=form)
def playercreate():
form = PlayerEntryForm()
if form.validate_on_submit():
newplayer = Player(playername=form.playername.data,
nationality=form.country.data,
club=form.club.data)
db.session.add(newplayer)
db.session.commit()
return redirect(url_for('playerlist'))
return render_template('playercreate.html', form=form)
def test_valid_player_field(app):
"""Verify Player fields saved properly."""
app = app(TestingConfig)
test_model_to_insert = Player(
player_name='Test Name',
player_image='testname.jpg',
position='PG',
first_nba_season=2019,
field_goal_made=100.3,
field_goal_attempted=100.3,
field_goal_pct=33.3,
three_pt_made=100.3,
three_pt_attempted=100.3,
three_pt_pct=33.3,
free_throw_made=100.3,
free_throw_attempted=100.3,
free_throw_pct=33.3,
true_stg_pct=33.3,
points=33.3,
off_reb=33.3,
def_reb=33.3,
tot_reb=33.3,
assists=33.3,
steals=33.3,
blocks=33.3,
turnovers=33.3,
)
db.session.add(test_model_to_insert)
db.session.commit()
assert db.session.query(Player).filter_by(player_name='Test Name').one()
assert db.session.query(Player).first().player_name == 'Test Name'
assert db.session.query(Player).first().player_image == 'testname.jpg'
assert db.session.query(Player).first().position == 'PG'
assert db.session.query(Player).first().first_nba_season == 2019
assert db.session.query(Player).first().field_goal_made == 100.3
assert db.session.query(Player).first().field_goal_attempted == 100.3
assert db.session.query(Player).first().field_goal_pct == 33.3
assert db.session.query(Player).first().three_pt_made == 100.3
assert db.session.query(Player).first().three_pt_attempted == 100.3
assert db.session.query(Player).first().three_pt_pct == 33.3
assert db.session.query(Player).first().free_throw_made == 100.3
assert db.session.query(Player).first().free_throw_attempted == 100.3
assert db.session.query(Player).first().free_throw_pct == 33.3
assert db.session.query(Player).first().true_stg_pct == 33.3
assert db.session.query(Player).first().points == 33.3
assert db.session.query(Player).first().off_reb == 33.3
assert db.session.query(Player).first().def_reb == 33.3
assert db.session.query(Player).first().tot_reb == 33.3
assert db.session.query(Player).first().assists == 33.3
assert db.session.query(Player).first().steals == 33.3
assert db.session.query(Player).first().blocks == 33.3
assert db.session.query(Player).first().turnovers == 33.3
def save_player(session, player_dict):
"""Save player to database"""
player = Player()
player.id = player_dict['id']
player.name = player_dict['name']
player.nation = player_dict['nation']
if 'registration_date' in player_dict:
player.registration_date = player_dict['registration_date']
session.add(player)
session.commit()
return player
