def player_list(request, format=None):
"""
List all code snippets, or create a new snippet.
"""
if request.method == 'GET':
snippets = Player.objects.all()
serializer = PlayerSerializer(snippets, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = PlayerSerializer(data=request.data)
print("In player list")
##d = Team(id=1, name="Thomas Davis")
##c = Player(id=9, name="Thomas", DOB='28/01/1998')
##d.players.add(c)
##data = request.data['Home_Team']
##snippet = Player.objects.get(name=name)
print(request.data['TeamID'])
if serializer.is_valid():
player = Player(name=request.data['name'], DOB=request.data['DOB'])
player.save()
print(player.name)
print(player.id)
##serializer.save()
addPlayer = Player(id=player.id,
name=request.data['name'],
DOB=request.data['DOB'])
team = Team(id=request.data['TeamID'])
team.players.add(addPlayer)
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
def setUp(self):
self.user1 = User.objects.create_user('user1', '', 'password')
self.user2 = User.objects.create_user('user2', '', 'password')
self.user3 = User.objects.create_user('user3', '', 'password')
self.player1 = Player(user=self.user1)
self.player2 = Player(user=self.user2)
self.player3 = Player(user=self.user3)
self.player1.save()
self.player2.save()
self.player3.save()
def setUp(self):
self.active_user = User.objects.create_user('active_user', '',
'password')
self.inactive_user = User.objects.create_user('inactive_user', '',
'password')
self.inactive_user.is_active = False
self.inactive_user.save()
self.player1 = Player(user=self.active_user)
self.player2 = Player(user=self.inactive_user)
self.player1.save()
self.player2.save()
def generate_players():
gender = 'male'
if reset():
gender = 'female'
name = names.get_first_name(gender=gender)
battles_total = random.randint(0, 200)
wins_total = random.randint(0, battles_total)
days_total = 123
vehicles_x = random.randint(0, 25)
if battles_total == 0:
exp_total = 0
else:
exp_total = random.randint(1000, 100000)
is_hidden = reset(20)
player = Player(name=name,
battles_total=battles_total,
wins_total=wins_total,
days_total=days_total,
vehicles_x=vehicles_x,
exp_total=exp_total,
is_hidden=is_hidden)
player.save()
def run():
print("importing player data now")
with open('./../resources/NFL Salary Visualization - nfl_salaries.csv', newline='') as csvfile:
reader = csv.DictReader(csvfile)
for row in reader:
first_name = row['player'].split(' ')[0]
last_name = row['player'].split(' ')[1]
salary = row['salary']
team_name = teams.teams[row['team']]
position_name = positions.positions[row['position']]
team = Team.objects.filter(name=team_name).first()
if not team:
team = Team(name=team_name, name_abbreviated=row['team'])
team.save()
position = Position.objects.filter(name=position_name).first()
if not position:
position = Position(name=position_name, name_abbreviated=row['position'])
position.save()
player = Player(
email='{}.{}@{}.net'.format(first_name, last_name, team.name_abbreviated),
first_name=first_name,
password='******',
last_name=last_name,
position=position,
team=team,
salary=int(salary))
player.save()
print('syncing now')
sync_entities()
def setUp(self):
self.game = Game()
self.game.save()
self.user1 = User.objects.create_user('user1', '', 'password')
self.user2 = User.objects.create_user('user2', '', 'password')
self.player1 = Player(user=self.user1)
self.player2 = Player(user=self.user2)
self.player1.save()
self.player2.save()
self.team1 = Team(player=self.player1, game=self.game)
self.team2 = Team(player=self.player2, game=self.game)
self.team1.save()
self.team2.save()
def get_golfer_by_id(self, player_id):
"""
Extracts data from a golfer based on their player_id. Looks like the
table on ESPN doesn't include every golfer that could potentially show
up in a tournament.
"""
response = requests.get(
"http://www.espn.com/golf/player/_/id/{}/".format(player_id))
if response.status_code == 200:
soup = BeautifulSoup(response.text, 'html.parser')
mod_content = soup.find("div", class_="mod-content")
player_bio = mod_content.find("div", class_="player-bio")
player_name_full = mod_content.find("h1").text
first_name = player_name_full.split(' ')[0]
last_name = " ".join(player_name_full.split(' ')[1:])
country = player_bio.find("ul", class_="general-info").find(
"li", class_="first").text
try:
existing_player = Player.objects.object(player_id=player_id)
print("Golfer with id: {} already exists".format(player_id))
except:
new_player = Player(player_id=player_id,
first_name=first_name,
last_name=last_name,
country=country)
new_player.save()
print("{} {} added to the players database".format(
first_name, last_name))
else:
raise ValueError(
"Could not find a player by id: {}".format(player_id))
def import_scores(table, game: Game, team: Team):
table_rows = table['data']
for table_row in table_rows[2:]:
row_data = [cell['text'] for cell in table_row]
player_number: str = row_data[0]
player_name: str = row_data[1]
if not player_number and not player_name:
return
if player_number in ('A', 'B', 'C', 'D'):
LOGGER.debug('SKIPPING Score (coach): %s - %s', player_number,
player_name)
return
if not player_number:
LOGGER.warning('SKIPPING Score (no player number): %s',
player_name)
return
if not player_name:
LOGGER.warning('SKIPPING Score (no player name): %s',
player_number)
return
try:
int(player_number)
except ValueError as err:
LOGGER.exception(
'invalid Score (invalid player number): %s - %s\n%s',
player_number, player_name, err)
return
player = Player(name=player_name, team=team)
score = parse_score(player, game, row_data)
logic.add_score(score)
def players(self, fake):
teams = Team.objects.all()
player = Role.objects.filter(type='P').first()
users = UserRole.objects.filter(role_id=player.id)
total = 0
for team in teams:
counter = 0
while counter < 10:
try:
player = Player(user_id=users[total].user.id,
team_id=team.id,
jersey_number=counter + 1,
height=fake.random_int(min=100,
max=255,
step=1))
except ObjectDoesNotExist:
raise Warning('Issue with adding user as Player')
player.save()
self.stdout.write(
self.style.SUCCESS('Player Created : %s %s' %
(users[total].user.first_name,
users[total].user.username)))
total += 1
counter += 1
def setUp(self):
self.user = User.objects.create_user('user1', '', 'password')
self.player = Player(user=self.user)
self.player.save()
self.winning_game = Game()
self.losing_game = Game()
self.in_progress_game = Game()
self.winning_game.save()
self.losing_game.save()
self.in_progress_game.save()
self.winning_team = Team(
game=self.winning_game,
player=self.player,
alive=True,
winner=True
)
self.losing_team = Team(
game=self.losing_game,
player=self.player,
alive=False,
winner=False
)
self.in_progress_team = Team(
game=self.in_progress_game,
player=self.player,
alive=True,
winner=False
)
self.winning_team.save()
self.losing_team.save()
self.in_progress_team.save()
def test_ship_creation(self):
"""Test that Ship instances are created correctly."""
game = Game()
game.save()
user = User(username='******', password='******')
user.save()
player = Player(user=user)
player.save()
team = Team(player=player, game=game)
team.save()
ship = Ship(
team=team,
x=0,
y=0,
length=3,
direction=Ship.CARDINAL_DIRECTIONS['WEST']
)
self.assertTrue(isinstance(ship, Ship))
self.assertEqual(
str(ship),
'Game 1 - user\'s 3L at (0, 0) facing West'
)
def create_player(request, player):
"Creates a new player"
try:
p = Player(pid=Player.generate_pid(), name=player)
p.save()
return JsonResponse(p.to_json())
except IntegrityError:
return JsonErrorResponse({'error': 'invalid name for new player'})
def test_player_creation(self):
"""Test that Game instances are created correctly."""
user = User(username='******', password='******')
user.save()
player = Player(user=user)
self.assertTrue(isinstance(player, Player))
self.assertEqual(str(player), 'user')
def setUp(self):
self.game = Game()
self.game.save()
self.user1 = User.objects.create_user('user1', '', 'password')
self.user2 = User.objects.create_user('user2', '', 'password')
self.player1 = Player(user=self.user1)
self.player2 = Player(user=self.user2)
self.player1.save()
self.player2.save()
self.team1 = Team(player=self.player1, game=self.game)
self.team2 = Team(player=self.player2, game=self.game)
self.team1.save()
self.team2.save()
self.ship = Ship(
team=self.team2,
x=3,
y=3,
length=3,
direction=Ship.CARDINAL_DIRECTIONS['SOUTH']
)
self.ship.save()
self.shot_miss = Shot(
game=self.game,
attacking_team=self.team1,
defending_team=self.team2,
x=2,
y=3
)
self.shot_miss.save()
self.shot_hit = Shot(
game=self.game,
attacking_team=self.team1,
defending_team=self.team2,
x=3,
y=5
)
self.shot_hit.save()
def regConPlayer(request):
club = request.POST['club']
name = request.POST['name']
gender = request.POST['gender']
nname = request.POST['nname']
qs = Player(p_club=club, p_name=name, p_gender=gender, p_nname=nname)
qs.save()
return HttpResponseRedirect(reverse('players:playerAll'))
def setUp(self):
self.game = Game()
self.game.save()
self.user = User.objects.create_user('user', '', 'password')
self.player = Player(user=self.user)
self.player.save()
self.team = Team(player=self.player, game=self.game)
self.team.save()
def setUp(self):
self.game1 = Game()
self.game2 = Game()
self.game1.save()
self.game2.save()
self.user1 = User.objects.create_user('user1', '', 'password')
self.user2 = User.objects.create_user('user2', '', 'password')
self.player1 = Player(user=self.user1)
self.player2 = Player(user=self.user2)
self.player1.save()
self.player2.save()
self.team_game1 = Team(player=self.player1, game=self.game1)
self.team_game2 = Team(player=self.player1,
game=self.game2,
alive=False)
self.team_game1.save()
self.team_game2.save()
def test_game_creation(self):
"""Test that Game instances are created correctly."""
game = Game()
game.save()
user1 = User.objects.create_user('user1', '', 'password')
user2 = User.objects.create_user('user2', '', 'password')
player1 = Player(user=user1)
player2 = Player(user=user2)
player1.save()
player2.save()
team1 = Team(player=player1, game=game)
team2 = Team(player=player2, game=game)
team1.save()
team2.save()
self.assertTrue(isinstance(game, Game))
self.assertEqual(str(game), '1 - user1 user2')
def test_shot_creation(self):
"""Test that Shot instances are created correctly."""
game = Game()
game.save()
attacking_user = User.objects.create_user(
'attacking_user',
'',
'password'
)
defending_user = User.objects.create_user(
'defending_user',
'',
'password'
)
attacking_user.save()
defending_user.save()
attacking_player = Player(user=attacking_user)
defending_player = Player(user=defending_user)
attacking_player.save()
defending_player.save()
attacking_team = Team(player=attacking_player, game=game)
defending_team = Team(player=defending_player, game=game)
attacking_team.save()
defending_team.save()
shot = Shot(
game=game,
attacking_team=attacking_team,
defending_team=defending_team,
x=0,
y=0
)
self.assertTrue(isinstance(shot, Shot))
self.assertEqual(
str(shot),
'Game 1 - attacking_user attacked defending_user (0, 0)'
)
def setUp(self):
self.game = Game()
self.game.save()
self.user1 = User.objects.create_user('user1', '', 'password')
self.user2 = User.objects.create_user('user2', '', 'password')
self.user3 = User.objects.create_user('user3', '', 'password')
self.player1 = Player(user=self.user1)
self.player2 = Player(user=self.user2)
self.player3 = Player(user=self.user3)
self.player1.save()
self.player2.save()
self.player3.save()
self.team1 = Team(player=self.player1, game=self.game, last_turn=1)
self.team2 = Team(player=self.player2, game=self.game, last_turn=2)
self.team3 = Team(player=self.player3, game=self.game, last_turn=3)
self.team1.save()
self.team2.save()
self.team3.save()
def test_existent_user(self):
user = User.objects.create_user('user1', '', 'password')
player = Player(user=user)
player.save()
url = reverse('player_profile', args=[user.username])
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
pq = PyQuery(resp.content)
self.assertEqual(pq('h2').text(), user.username)
def regConPlayer(request) :
pid = request.POST['pid']
nick = request.POST['nick']
email = request.POST['email']
name = request.POST['name']
birth = request.POST['birth']
position = request.POST['position']
team = request.POST['team']
qs = Player(p_pid=pid, p_nick=nick, p_email=email, p_name=name, p_birth=birth, p_position=position, p_team=team)
qs.save()
return HttpResponseRedirect(reverse('players:playerAll'))
def test_team_creation(self):
"""Test that Team instances are created correctly."""
game = Game()
game.save()
user = User.objects.create_user('user', '', 'password')
player = Player(user=user)
player.save()
team = Team(player=player, game=game)
self.assertTrue(isinstance(team, Team))
self.assertEqual(str(team), 'Game 1 - user (last_turn=0)')
def create_player(player):
"""Creates an quarterback object combining different elements from the list"""
player = Player(
year=player["year"],
name=player["name"],
team=player["team"],
position=player["position"],
rush_attempts=player["rush_attempts"],
rush_yards=player["rush_yards"],
yards_per_rush=player["yards_per_rush"],
rush_touchdowns=player["rush_touchdowns"],
rushes_per_touchdown=player["rushes_per_touchdown"],
fumbles=player["fumbles"],
pass_attempts=player["pass_attempts"],
pass_completions=player["pass_completions"],
completion_percentage=player["completion_percentage"],
pass_yards=player["pass_yards"],
yards_per_pass_attempt=player["yards_per_pass_attempt"],
yards_per_completion=player["yards_per_completion"],
pass_touchdowns=player["pass_touchdowns"],
passes_per_touchdown=player["passes_per_touchdown"],
interceptions=player["interceptions"],
targets=player["targets"],
receptions=player["receptions"],
catch_percentage=player["catch_percentage"],
receiving_yards=player["receiving_yards"],
yards_per_reception=player["yards_per_reception"],
yards_per_target=player["yards_per_target"],
receiving_touchdowns=player["receiving_touchdowns"],
receptions_per_touchdown=player["receptions_per_touchdown"],
targets_per_touchdown=player["targets_per_touchdown"],
total_attempts=player["total_attempts"],
total_yards=player["total_yards"],
yards_per_attempt=player["yards_per_attempt"],
total_touchdowns=player["total_touchdowns"],
attempts_per_touchdown=player["attempts_per_touchdown"],
games=player["games"],
attempts_per_game=player["attempts_per_game"],
points=player["points"],
points_per_game=player["points_per_game"],
points_per_attempt=player["points_per_attempt"],
average_value_over_replacement=player[
"average_value_over_replacement"],
starting_value_over_replacement=player[
"starting_value_over_replacement"])
player.save()
return player
def test(request):
if request.method == 'POST':
# create a form instance and populate it with data from the request:
form = HomeForm(request.POST)
# check whether it's valid:
if form.is_valid():
# process the data in form.cleaned_data as required
# ...
# redirect to a new URL:
post = Player()
return HttpResponseRedirect('http://127.0.0.1:8000/world/home/')
# if a GET (or any other method) we'll create a blank form
else:
form = HomeForm()
return render(request, "test.html", {'form': form})
def settingsRefreshPlayers(request):
item = "NEMA"
if request.method == "POST":
log = request.POST.get('log')
players = []
rows_created = 0
rows_updated = 0
for item in log.splitlines():
if "' logged in" in item:
steam_id = ""
ingame_name = ""
server_id = ""
item = item.split("'")
#item = item[2].split(':')
steam_id = item[1].split(':')[0].split(' ')[1]
#item = item[1].split('(')
ingame_name = item[1].split(':')[1].split('(')[0]
server_id = item[1].split(':')[1].split('(')[1][:-1]
if server_id.isdigit():
obj = Player.objects.filter(steam_id=steam_id).first()
if obj is None:
player = Player(steam_id=steam_id,
ingame_name=ingame_name,
server_id=int(server_id))
player.save()
rows_created += 1
#line = str(steam_id) + '###' + str(ingame_name) + '###' + str(server_id)
#players.append(line)
else:
if obj.ingame_name != ingame_name or obj.server_id != int(
server_id):
obj.server_id = int(server_id)
obj.save()
rows_updated += 1
item = players
messages.success(
request, 'Players created: ' + str(rows_created) +
' Players updated: ' + str(rows_updated))
page_title = " - Refresh player list"
context = {'page_title': page_title, 'item': item}
return render(request, 'settings/settings_login_refresh.html', context)
def handle(self, *args, **options):
number = 10
if options['number']:
number = options['number']
for i in range(0, number):
gender = 'male'
if self.reset():
gender = 'female'
name = names.get_first_name(gender=gender)
battles_total = random.randint(0, 1200)
wins_total = random.randint(0, battles_total)
if wins_total > 0:
days_total = random.randint(1, 1000)
else:
days_total = 0
vehicles_x = random.randint(0, 25)
if battles_total == 0:
exp_total = 0
else:
exp_total = random.randint(1000, 100000)
is_hidden = self.reset(15)
date = timezone.now() - timedelta(days=days_total)
player = Player(name=name,
battles_total=battles_total,
wins_total=wins_total,
days_total=days_total,
vehicles_x=vehicles_x,
exp_total=exp_total,
is_hidden=is_hidden,
created_at=date)
try:
player.save()
except IntegrityError as e:
print('Catch unique name')
player.name += str(random.randint(1, 9999))
player.save()
def post(self, request, format=None):
postArgs = request.POST
race = Race.objects.get(id=int(postArgs["race"]))
actorClass = Class.objects.get(id=int(postArgs["class"]))
#TODO Store rolls and use the last one rather than accepting any input, in case there are cheaters...
newPlayer = Player(base_strength=int(postArgs["str"]),
base_dexterity=int(postArgs["dex"]),
base_constitution=int(postArgs["con"]),
base_intelligence=int(postArgs["int"]),
base_wisdom=int(postArgs["wis"]),
base_charisma=int(postArgs["cha"]),
race=race,
actor_class=actorClass,
owner=request.user)
newPlayer.save()
return Response({"ok": True})
def post(self, request, *args, **kwargs):
user_form = UserForm(data=request.POST)
player_form = PlayerForm(data=request.POST)
if user_form.is_valid() and player_form.is_valid():
user = user_form.save()
user.set_password(user.password)
user.save()
player = Player(user=user)
player.save()
user = authenticate(username=user_form.cleaned_data['username'],
password=user_form.cleaned_data['password'])
login(request, user)
return HttpResponseRedirect('/')
else:
context = {'user_form': user_form}
messages.error(request, 'Something went wrong...')
return render(request, self.template_name, context)
def stat_list(request, format=None):
"""
List all code snippets, or create a new snippet.
"""
if request.method == 'GET':
snippets = Statistics.objects.all()
print(snippets)
serializer = StatisticSerializer(snippets, many=True)
return Response(serializer.data)
elif request.method == 'POST':
serializer = StatisticSerializer(data=request.data)
print(serializer)
if serializer.is_valid():
p = Player(id=request.data['Player_ID'])
f = Fixture(id=request.data['Fixture_ID'])
stat = Statistics(Player_ID=p,
Fixture_ID=f,
Pass=0,
Pass_Miss=0,
Point=0,
Point_Miss=0,
Goal=0,
Goal_Miss=0,
Turnover=0,
Dispossessed=0,
Block=0,
Kickout_won=0,
Kickout_lost=0,
Goal_save=0,
Goal_conceded=0,
Yellow_card=0,
Red_card=0,
Black_card=0)
stat.save()
##serializer.save()
return Response(serializer.data, status=status.HTTP_201_CREATED)
return Response(serializer.errors, status=status.HTTP_400_BAD_REQUEST)
