def compensate_send():
data = json.loads(request.data)
Player.player_compensate(data)
compensate = Compensate(comment=data["comment"], content=request.data, author_id=current_user.id)
login_db.session.add(compensate)
login_db.session.commit()
return ""
def save_player(self, player_data): player_name = player_data['name'] player_school = player_data['school'] player_town = player_data['town'] player_team = player_data['team'] try: player = Player.objects.get(name=player_name, school=player_school, town=player_town, team = player_team) print 'EXISTING PLAYER FOUND!!!' except Player.DoesNotExist: player = Player(**player_data) player.save()
def save_player(self, player_data):
player_name = player_data["name"]
player_school = player_data["school"]
player_town = player_data["town"]
player_team = player_data["team"]
try:
player = Player.objects.get(name=player_name, school=player_school, town=player_town, team=player_team)
print "EXISTING PLAYER FOUND!!!"
except Player.DoesNotExist:
player = Player(**player_data)
player.save()
def player_search_name():
if request.method == "GET":
player_name = request.args.get('name')
# player = Player.player_test()
player = Player.player_find_by_name(player_name)
if not player:
return ""
return JSONEncoder().encode(player)
else:
player_data = json.loads(request.data)
# 预处理player变量 纠正变量类型
adjust_player_data(player_data)
Player.player_find_and_replace_by_id(player_data["_id"], player_data)
return ""
def player_building_save():
data = json.loads(request.data)
data["_id"] = ObjectId(data["_id"])
data["building_lv"] = int(data["building_lv"])
Player.collection.update_one({"_id": data["_id"]}, {"$set": {"buildings.%s.level" % data["building_pos"]: data["building_lv"]}})
player = Player.player_find_by_id(data["_id"])
return JSONEncoder().encode(player)
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()
class AddPlayerCommand(Command):
"""Handle the book deletion."""
key = "add"
readable_key = key
description = "Add a player to the db."
def __init__(self, player_info):
"""Init the command and the player to add to the db."""
self.player = Player(
**player_info) if player_info else Player.auto_init()
def execute(self, context):
"""Add the player and go to the main page."""
self.player.save()
context.change_page("mainpage")
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 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 get_player_list_letter(startswith):
page = request.args.get('page', 1, type=int)
per_page = min(request.args.get('per_page', 10, type=int), 50)
data = Player.to_collection_dict(
Player.query.filter(Player.player_name.startswith(startswith)),
page, per_page, 'api.get_player_list_letter', startswith=startswith)
return jsonify(data)
def purchased_players_view(username):
data = dict()
data['players'] = Player.order_by(('score', User.ORDER_DESCENDING),
('price', User.ORDER_DESCENDING),
query={'owner_username': username})
data['summary'] = player_summary(data['players'])
return data
def __call__(self):
data = dict()
# Game
data['game'] = list()
game = Game.read()
if game:
data['game'].append(game.to_dict())
# User
data['user'] = list()
users = User.get_all()
for user in users:
user_dict = user.to_dict()
data['user'].append(user_dict)
# Player
data['player'] = list()
players = Player.get_all()
for player in players:
data['player'].append(player.to_dict())
# Bid
data['bid'] = list()
bids = Bid.get_all()
for bid in bids:
data['bid'].append(bid.to_dict())
# Write to the file
with open(self.file_name, 'w') as json_file:
json.dump(data,
json_file,
ensure_ascii=False,
sort_keys=True,
indent=4)
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 accept_bid(bid, user, amount=Bid.PASS):
transaction = Bid.get_transaction()
bid_result = accept_bid_transaction(transaction, bid, user, amount)
if bid_result <= 0:
return bid_result
bid.refresh()
game = Game.read()
if not bid.is_bid_complete(game.user_count):
return Bid.SUCCESS
# Determine Winner
player = Player.query_first(name=bid.player_name)
winning_bid = max(bid.bid_map, key=lambda bid_dict: bid_dict['amount'])
if winning_bid['amount'] < 1:
purchase_player_transaction(transaction, player)
else:
winning_bids = [
bid_dict for bid_dict in bid.bid_map
if bid_dict['amount'] == winning_bid['amount']
]
if len(winning_bids) > 1:
winning_index = random.randrange(0, len(winning_bids))
winning_bid = winning_bids[winning_index]
winner = User.query_first(username=winning_bid['username'])
purchase_player_transaction(transaction, player, winner,
winning_bid['amount'])
bid.winner = winning_bid['username']
bid.winning_price = winning_bid['amount']
bid.update()
# Invite another bid
return invite_bid()
def register_view():
# TODO: add the registration date
form = RegistrationForm()
if form.validate_on_submit():
player = Player()
role = Role.query.filter_by(role='player').first()
player.role_id = role.id
form.populate_obj(player)
db.session.add(player)
db.session.commit()
login_user(player)
return redirect(url_for('player_home_view'))
return render_template('registration_form.html', form=form)
def get_players():
"""Return all existing players in database."""
page = request.args.get('page', 1, type=int)
order_by = request.args.get('order_by')
players = Player.get_all(order_by=order_by)
response = paginate_response(players, page=page)
return jsonify(response), 200
def put(self, _id):
try:
data = PlayerById.parser.parse_args()
if Player.find_by_name(*data):
return msg(
'Player {} already exists. Please choose a different name'
), 400
player = Player.find_by_id(_id)
if player:
player.name = data['name']
player.save_to_db()
return player.json(), 201
else:
return msg('Player {} does not exist'.format(_id)), 400
except:
return msg(
'An error occured while updating player {}'.format(_id)), 500
def get_player(nickname):
"""Retrieve single player instance from database."""
player = Player.get_player_stats(nickname)
if player is None:
return jsonify({'message': 'Player instance could not be found.'}), 404
response = player.to_dict()
return jsonify(response), 200
def get_server_players(endpoint):
"""Return list of players on server."""
page = request.args.get('page', 1, type=int)
order_by = request.args.get('order_by')
players = Player.get_all(order_by=order_by, endpoint=endpoint)
response = paginate_response(players, page=page)
return jsonify(response), 200
def score(data=None, decrypt=True):
data = data or request.data
if not data:
logging.warning('Empty request')
return 'No data', 400
print('got a score!!')
print(data)
data = dumb_decryption(data) if decrypt else data
try:
player = Player.query.get(data['player']['id'])
if not player:
player = Player(data['player'])
else:
player.update_fields(data['player'])
chart = Chart.query.get(data['chart']['chart_id'])
if not chart:
chart = Chart(data['chart'])
else:
chart.update_fields(data['chart'])
data['score']['hash'] = data['chart'].get('hash')
score = Score(data['score'], chart)
score.achieved_at = datetime.utcnow()
score.player = player
score.version = 6
if not score.is_supported():
db.session.rollback()
print('score ignored because not supported')
return 'Not OK'
db.session.add_all([player, chart, score])
db.session.commit()
print('pushed to db! ({} played by {})'.format(chart.name,
player.username))
score.set_osmos()
print('osmos set')
print('updating pb if needed')
if update_pb_for_score(player, score):
print('updated pb returned true')
update_player_osmos(player)
player.playcount += 1
db.session.commit()
except Exception as e:
db.session.rollback()
logging.warning(f'Malformed score payload: \n{data}')
raise logging.warning(e, exc_info=True)
return 'OK'
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 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_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 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 create_player():
data = request.get_json()
add_user = Player(nama=data['nama'],
jk=data['jk'],
tgllahir=data['tgllahir'],
email=data['email'],
latitude=data['latitude'],
longitude=data['longitude'],
username=data['username'])
add_user.hash_password(data['password'])
db.session.add(add_user)
db.session.commit()
return jsonify({
'message':
'Congratulation You Has Been Registered, Check Your Email'
})
def test_DB():
player = Player()
player.login = '******'
scenario = Scenario()
scenario.name = 'scenario 1'
scenario.leadtime = 10
scenario.duration = 20
gameboard = GameBoard()
gameboard.period = 1
# T = TableDict(10)
# T.set_cell('order', 5, 1000)
# T.set_cell('forecast', 8, 10)
gameboard.data = TableDict(10)
gameboard.data.set_cell('order', 5, 1000)
gameboard.data.set_cell('forecast', 8, 10)
scenario_counter = ScenarioCounter()
player.gameboards.append(gameboard)
player.played_scenario.append(scenario)
player.scenario_counters.append(scenario_counter)
scenario.gameboards.append(gameboard)
scenario.counters.append(scenario_counter)
db.session.add(player)
db.session.add(scenario)
db.session.add(gameboard)
db.session.add(scenario_counter)
db.session.commit()
pl = db.session.query(Player).first()
assert_equal('Pippo', pl.login)
assert_equal('scenario 1', pl.played_scenario[0].name)
d = pl.gameboards.filter(GameBoard.scenario_id==scenario.id).first()
assert_in('<table', d.data.get_HTML())
assert_equal(d.data.get_cell('order', 5), 1000)
assert_equal(d.data.get_cell('order', 8), 0)
assert_equal(d.data.get_cell('forecast', 8), 10)
assert_equal(d.data.get_cell('forecast', 1), 0)
assert_equal(d.data.get_cell('forecast', 15), None)
def sign_up():
"""
Creates a new user and logs them in
"""
form = SignUpForm()
form['csrf_token'].data = request.cookies['csrf_token']
if form.validate_on_submit():
user = Player(username=form.data['username'],
ntrp=form.data['ntrp'],
password=form.data['password'])
db.session.add(user)
db.session.commit()
login_user(user)
return user.to_dict()
return {'errors': validation_errors_to_error_messages(form.errors)}, 401
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 auth_register(username, password, password2):
error = False
wrong_password, something, please_enter, user_exists = None, None, None, None
if username and password and password2:
if password == password2:
check_player = Player.query.filter_by(name=username).first()
if not check_player:
try:
pa = password.encode()
h = hashlib.sha256(pa + salt).hexdigest()
random = Random(10)
player = Player(name=username, password=h, random=random)
Player.insert(player)
user_id = player.id
except:
app.logger.info(sys.exc_info())
error = True
something = 'Something went wrong. Please try again.'
db.session.rollback()
finally:
db.session.close()
else:
error = True
user_exists = 'Username unawailable. Such user allready exists'
else:
error = True
wrong_password = '******'
else:
error = True
please_enter = 'Please provide user name and password!'
if error:
return {
'success': False,
'passwordMsgRe': wrong_password,
'userExists': user_exists,
'enterMsgRe': please_enter,
'something': something
}
else:
session['user'] = username
session['info'] = random
session['userId'] = user_id
return {'success': True}
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 get_all_players():
"""
Queries database for the entire player table, paginates results, and
returns JSON response.
"""
page = request.args.get('page', 1, type=int)
per_page = min(request.args.get('per_page', 10, type=int), 50)
data = Player.to_collection_dict(Player.query, page, per_page,
'api.get_all_players')
return jsonify(data)
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 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 create_player():
"""Create new player instance."""
json_data = request.get_json()
if not json_data:
return jsonify({'error': 'No required input data provided.'}), 400
data, errors = Player.from_dict(json_data)
if errors:
return jsonify(errors), 400
player = Player.get(data.get('nickname'))
if player:
return jsonify({'error':
'Player with this nickname already exists.'}), 409
# Create a new player instance
player = Player(data)
response = player.to_dict()
return jsonify(response), 201
def player_building_save():
data = json.loads(request.data)
data["_id"] = ObjectId(data["_id"])
data["building_lv"] = int(data["building_lv"])
Player.collection.update_one({"_id": data["_id"]}, {
"$set": {
"buildings.%s.level" % data["building_pos"]: data["building_lv"]
}
})
player = Player.player_find_by_id(data["_id"])
return JSONEncoder().encode(player)
def players(request):
"""
Returns the results in the current match. Will check for cached result before calculation. The cache is invalidated
on recorded action.
"""
cache = get_cache('default')
players = cache.get("players")
if not players:
players = Player.get_results()
cache.set('players', players)
return Response(players)
def add_player(self, player_name, player_sid):
"""Add player into game in DB"""
player_in_db = Player.query.filter_by(name=player_name).first()
player = Player(name=player_name,
sid=player_sid) if not player_in_db else player_in_db
print self.game_id
game = Game.query.get(self.game_id)
game.players.append(player)
db.session.add(player)
db.session.commit()
db.session.close()
def players(request):
"""
Returns the results in the current match. Will check for cached result before calculation. The cache is invalidated
on recorded action.
"""
cache = get_cache('default')
players = cache.get("players")
if not players:
players = Player.get_results()
cache.set('players', players)
return Response(players)
def populate():
Position.insert_positions()
with app.open_resource('./testing/data/teams.json') as teamdata:
team_dict = json.load(teamdata)['teams']
team_models = []
for t in team_dict:
Team.add_team(name=t['name'],
conference=t['conference'],
gm=t['gm'],
season=2014)
with app.open_resource('./testing/data/players.json') as playerdata:
player_dict = json.load(playerdata)['players']
for p in player_dict:
Player.add_player(name=p['name'],
positions=p['positions'],
team=p['team'])
Player_Season
populate_games()
populate_stats()
def record_action(request):
"""
Records a match event. After recording, reset the cache.
The post arguments are team, name, action, seconds_in_game
"""
#todo defensive for wrong post data
name = request.POST.get("name")
team = request.POST.get("team")
action = request.POST.get("action")
seconds_in_game = request.POST.get("seconds_in_game")
#get or create the player
player, created = Player.objects.get_or_create(
name=name,
team=team
)
#create the action
action = PlayerAction.objects.create(
player=player,
type=action,
seconds_in_game=seconds_in_game
)
#create the scoring for users
affected_users = [up['user'] for up in UserPlayer.objects.filter(player=player).values('user')]
userscores= []
for user_id in affected_users:
userscore = UserScore(
playeraction=action,
user_id=user_id
)
userscores.append(userscore)
UserScore.objects.bulk_create(userscores)
#reset the cache
cache= get_cache('default')
players = Player.get_results()
cache.set('players', players)
users = User.get_results()
cache.set("users", users)
return Response({'success':True})
def adjust_player_data(player_data):
player_data["_id"] = ObjectId(player_data["_id"])
new_player = Player.player_find_by_id(player_data["_id"])
# buildings
player_data["buildings"] = new_player["buildings"]
# for pos in player_data["buildings"]:
# player_data["buildings"][pos]["construct_id"] = int(player_data["buildings"][pos]["construct_id"])
# player_data["buildings"][pos]["level"] = int(player_data["buildings"][pos]["level"])
# resource
for resource_type in player_data["resource"]:
if resource_type in ["updated", "diamond"]:
player_data["resource"][resource_type] = int(player_data["resource"][resource_type])
else:
player_data["resource"][resource_type] = float(player_data["resource"][resource_type])
# resource_delta
for resource_type in player_data["resource_delta"]:
player_data["resource_delta"][resource_type] = float(player_data["resource_delta"][resource_type])
def player_single_save():
data = json.loads(request.data)
adjust_single_data(data)
Player.player_update_single_field(data)
player = Player.player_find_by_id(data["_id"])
return JSONEncoder().encode(player)
import csv
from app.models import Player
import os
import django
django.setup()
os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'freepl_main.settings')
# to run this file, do python3 manage.py runshell and then do exec(open("load.py").read())
for i in Player.objects.all():
i.delete()
with open('indiaaus.csv') as f:
reader=csv.DictReader(f)
for row in reader:
p=(row['Player Name'].strip())
c="".join(row['Cost'].split())
r="".join(row['Role'].split())
n="".join(row['Country'].split())
c=int(c)
z=Player(name=p,cost=c,role=r,country=n)
z.save()
def handle_noargs(self, **options):
cursor = connections['import'].cursor()
# Import players
cursor.execute('SELECT ID, Name FROM Player')
row = cursor.fetchone()
players = {}
while row:
try:
player = Player.objects.get(name=row[1])
except Player.DoesNotExist:
player = Player(name=row[1])
player.save()
players[row[0]] = player
row = cursor.fetchone()
cursor.execute('''
SELECT EventID, Event.Date, PlayerID, [1st], [2nd], [3rd], [4th]
FROM Result INNER JOIN Event on Event.ID = Result.EventID
WHERE EventID > 3
ORDER BY Event.Date ASC
''')
# Import events
event_id = 0
event = None
row = cursor.fetchone()
transaction.commit_unless_managed()
transaction.enter_transaction_management()
transaction.managed(True)
try:
while row:
if event_id != row[0]:
event = Event(event_date=row[1])
try:
event.save()
event_id = row[0]
event_points = 0
self.stdout.write("Importing event %s\n" % event)
except IntegrityError:
# Event already exists, skip it
self.stdout.write("Skipping event %s (already imported)\n" % row[0])
# Only process result if a saved event exists
if event.pk is not None:
result = EventResult(event=event, player=players[row[2]], firsts=row[3], seconds=row[4], thirds=row[5], fourths=row[6])
result.save()
event_points += result.points
if event.results.count() == 4:
if event_points != MAX_EVENT_POINTS:
# Discard invalid events
event.delete()
self.stdout.write("Discarding event %s[%s] (invalid number of points: %s)\n" % (event, event_id, event_points))
else:
# Complete event
event.completed = True
event.save()
row = cursor.fetchone()
except:
transaction.rollback()
transaction.leave_transaction_management()
self.stdout.write("Unexpected error importing events")
raise
return
transaction.commit()
transaction.leave_transaction_management()
