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 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.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 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 linkaccounts(request):
if not request.user.is_authenticated():
return HttpResponseRedirect('/')
if request.method == 'POST':
username = request.POST['MCUsername']
password = request.POST['MCPassword']
verified = minecraft.connect_minecraft(username, password)
if verified is False:
return render(request, 'linkaccounts.html', {
'error': True,
'errormsg': 'minerap.com does not recognize your login credentials. Please try again'
})
else:
if utils.minecraftAccountAlreadyExists(verified):
return render(request, 'linkaccounts.html', {
'error': True,
'errormsg': 'Your minecraft account has already been registered on The White Book. Please use another.'
})
else:
now = datetime.datetime.utcnow().replace(tzinfo=utc)
player = Player(user=request.user, mc_username=verified, score=0, rank=0, most_recent=(now - datetime.timedelta(seconds=60)))
player.save()
return HttpResponseRedirect('/')
if request.method == 'GET':
return render(request, 'linkaccounts.html', {})
class PlayerPresenterTestCase(TestCase):
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_from_player(self):
presenter = PlayerPresenter.from_player(self.player)
self.assertEqual(presenter.username, self.user.username)
self.assertEqual(presenter.win_count, 1)
self.assertEqual(presenter.loss_count, 1)
self.assertEqual(presenter.in_progress_count, 1)
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()
class TeamPresenterTestCase(TestCase):
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 test_from_team(self):
presenter = TeamPresenter.from_team(team=self.team, game=self.game)
self.assertEqual(presenter.player.username, self.user.username)
self.assertTrue(presenter.is_next)
self.assertEqual(presenter.winner, self.team.winner)
self.assertEqual(presenter.alive, self.team.alive)
self.assertEqual(len(presenter.tiles), GAME_SIZE)
self.assertEqual(len(presenter.tiles[0]), GAME_SIZE)
def test_make_tiles(self):
tiles = TeamPresenter.make_tiles(team=self.team, game=self.game)
self.assertEqual(len(tiles), GAME_SIZE)
for i in range(0, GAME_SIZE):
self.assertEqual(len(tiles[i]), GAME_SIZE)
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.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 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 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 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 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 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)')
class LogoutViewTestCase(TestCase):
def setUp(self):
self.user = User.objects.create_user('user', '', 'password')
self.player = Player(user=self.user)
self.player.save()
def test_get(self):
self.client.login(username=self.user.username, password='******')
url = reverse('logout')
resp = self.client.get(url)
self.assertRedirects(resp, reverse('home'))
self.assertNotIn('_auth_user_id', self.client.session)
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 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 handle(self, player, game, play):
if self.game.status is Game.WAITING:
return JsonErrorResponse({'error': 'game has not started'})
if self.game.status is Game.COMPLETE:
return JsonErrorResponse({'error': 'game has ended'})
if self.player not in self.game.players.all():
return JsonErrorResponse({'error': 'player is not in game'})
if self.game.status is Game.STATUS[2]:
return JsonErrorResponse({'error': 'game is over'})
if play not in self.game.hand(self.player):
return JsonErrorResponse({'error': 'illegal play'})
turn = self.game.turns.all()[0]
if turn.plays.filter(player=self.player).exists():
return JsonErrorResponse({'error': 'already played this turn'})
turn.plays.create(player=self.player, play=play)
if self.game.autoplay:
bot = Player.bot_player()
strategy = strategies[settings.BOT_STRATEGY]
turn.plays.create(player=bot,
play=strategy(
self.game.to_json(mask_for_player=bot)))
if turn.is_complete():
if self.game.is_complete():
self.game.finalize()
self.game.save()
else:
self.game.add_turn()
log.info("{} played {} in {}".format(self.player, play, self.game))
return redirect('show_game', self.player.pid, self.game.gid)
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 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 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 getstats(request):
if request.method == 'POST':
# Get data
player = request.POST['player_name']
week = request.POST['week']
year = request.POST['year']
response = Player.getStats(player, week, year)
return JsonResponse(response)
def getstats(request):
if request.method == 'POST':
# Get data
player = request.POST['player_name']
week = request.POST['week']
year = request.POST['year']
response = Player.getStats(player, week, year)
return JsonResponse(response)
class SignupViewTestCase(TestCase):
def setUp(self):
self.user = User.objects.create_user('user', '', 'password')
self.player = Player(user=self.user)
self.player.save()
def test_get_logged_out(self):
url = reverse('signup')
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
pq = PyQuery(resp.content)
self.assertEqual(len(pq('input#id_username')), 1)
self.assertEqual(len(pq('input#id_password')), 1)
def test_get_logged_in(self):
self.client.login(
username=self.user.username,
password='******'
)
url = reverse('signup')
resp = self.client.get(url)
self.assertRedirects(resp, reverse('home'))
def test_post(self):
url = reverse('signup')
resp = self.client.post(url, {
'username': ['newuser'],
'password': ['password']
})
player = Player.objects.all().order_by('-id')[0]
self.assertEqual(player.user.username, 'newuser')
self.assertTrue(player.user.check_password('password'))
self.assertRedirects(resp, reverse('home'))
self.assertIn('_auth_user_id', self.client.session)
self.assertEqual(
int(self.client.session['_auth_user_id']),
player.user.id
)
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()
class LogoutViewTestCase(TestCase):
def setUp(self):
self.user = User.objects.create_user('user', '', 'password')
self.player = Player(user=self.user)
self.player.save()
def test_get(self):
self.client.login(
username=self.user.username,
password='******'
)
url = reverse('logout')
resp = self.client.get(url)
self.assertRedirects(resp, reverse('home'))
self.assertNotIn('_auth_user_id', self.client.session)
class PlayerPresenterTestCase(TestCase):
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_from_player(self):
presenter = PlayerPresenter.from_player(self.player)
self.assertEqual(presenter.username, self.user.username)
self.assertEqual(presenter.win_count, 1)
self.assertEqual(presenter.loss_count, 1)
self.assertEqual(presenter.in_progress_count, 1)
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 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 handle(self, player, game):
if self.game.status == Game.WAITING:
self.game.autoplay = True
self.game.players.add(Player.bot_player())
self.game.status = Game.PLAYING
self.game.add_turn()
self.game.save()
log.info("{} set {} to autoplay".format(self.player, self.game))
return redirect('show_game', self.player.pid, self.game.gid)
else:
return JsonErrorResponse({'error': 'game already started'})
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 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)
class SignupViewTestCase(TestCase):
def setUp(self):
self.user = User.objects.create_user('user', '', 'password')
self.player = Player(user=self.user)
self.player.save()
def test_get_logged_out(self):
url = reverse('signup')
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
pq = PyQuery(resp.content)
self.assertEqual(len(pq('input#id_username')), 1)
self.assertEqual(len(pq('input#id_password')), 1)
def test_get_logged_in(self):
self.client.login(username=self.user.username, password='******')
url = reverse('signup')
resp = self.client.get(url)
self.assertRedirects(resp, reverse('home'))
def test_post(self):
url = reverse('signup')
resp = self.client.post(url, {
'username': ['newuser'],
'password': ['password']
})
player = Player.objects.all().order_by('-id')[0]
self.assertEqual(player.user.username, 'newuser')
self.assertTrue(player.user.check_password('password'))
self.assertRedirects(resp, reverse('home'))
self.assertIn('_auth_user_id', self.client.session)
self.assertEqual(int(self.client.session['_auth_user_id']),
player.user.id)
class IsTeamNextTestCase(TestCase):
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_team_is_next(self):
self.assertTrue(is_team_next(self.team1, self.game))
def test_team_is_not_next(self):
self.assertFalse(is_team_next(self.team2, self.game))
self.assertFalse(is_team_next(self.team3, self.game))
def test_non_alive_team(self):
self.team1.alive = False
self.team1.save()
self.assertTrue(is_team_next(self.team2, self.game))
class GamePresenterTestCase(TestCase):
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 test_from_game(self):
presenter = GamePresenter.from_game(self.game)
self.assertEqual(presenter.id, self.game.id)
self.assertEqual(len(presenter.teams), 2)
def post(self, request, *args, **kwargs):
nick = request.POST.get('nickname')
faction = request.POST.get('faction')
level = request.POST.get('level')
ap = request.POST.get('ap')
email = request.POST.get('email')
if not nick and faction and level and ap and email:
return HttpResponseBadRequest(
content=json.dumps({'error': 'Bad request. '
'Must include all the necessary '
'fields.'}),
content_type='application/json'
)
try:
player = Player.objects.get(email=email)
except Player.DoesNotExist:
player = Player()
player.nickname = nick
if faction == u'RESISTANCE':
player.faction = player.FACTION_CHOICES.RESISTANCE
else:
player.faction = Player.FACTION_CHOICES.ENLIGHTENED
player.ap = int(ap)
player.email = email
player.save()
response = OrderedDict()
response['status'] = 'success'
response['position'] = player.position()
return HttpResponse(
content=json.dumps(response),
content_type='application/json'
)
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_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)'
)
class IsTeamNextTestCase(TestCase):
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_team_is_next(self):
self.assertTrue(is_team_next(self.team1, self.game))
def test_team_is_not_next(self):
self.assertFalse(is_team_next(self.team2, self.game))
self.assertFalse(is_team_next(self.team3, self.game))
def test_non_alive_team(self):
self.team1.alive = False
self.team1.save()
self.assertTrue(is_team_next(self.team2, self.game))
import sys
import os
import csv
sys.path.append(os.path.abspath(os.path.curdir))
os.environ['DJANGO_SETTINGS_MODULE'] = 'fantasyfootball.settings'
from players.models import Player
player_file = 'playerout.csv'
with open(player_file,'rb') as f:
reader = csv.reader(f,delimiter=',')
for row in reader:
player = Player(name = row[0], team_name = row[1], player_position = row[4], buy_value = row[2], next_three = row[5], last_three =row[6], expected= row[10], idn = row[9], news =row[3], chance_of_playing =row[8] , expected_three=row[11])
try:
player.save()
except:
# if the're a problem anywhere, you wanna know about it
print "there was a problem with line"
raise
def create(request, team_id):
if request.method == "POST":
name = request.POST.get('name')
number = request.POST.get('number')
position = request.POST.get('position')
height = request.POST.get('height', '')
weight = request.POST.get('weight', '')
birthday = request.POST.get('birthday', '')
email = request.POST.get('email', '')
#isAdmin = request.POST.get('isAdmin')
# Team instance
try:
team = Team.objects.get(id=team_id)
except:
team = None
if team:
try:
image = request.FILES['image']
player = Player(team=team, name=name, number=number,
figure=image, position=position, birthday=birthday,
email=email, height=height, weight=weight)
except: # Without image.
player = Player(team=team, name=name, number=number,
position=position, birthday=birthday, email=email,
height=height, weight=weight)
#if isAdmin == "true":
# player.isAdmin = True
#else:
# player.isAdmin = False
try:
player.save()
except:
# TODO: Log system.
# 2016.05.24 Message framework.
messages.error(request, _('UNABLED_TO_CREATE_PLAYER'))
return redirect('player_index', team_id=team_id)
#player.team.add(team)
# Init time.
time = datetime.datetime.strptime(u'00:00', '%M:%S')
try:
# Init PlayerState object.
PlayerState(player=player, game_played=0, game_started=0, time=time,
two_points_attempt=0, two_points_made=0,
three_points_attempt=0, three_points_made=0,
FTA=0, FTM=0, OREB=0, DREB=0, REB=0, AST=0, STL=0, BLK=0,
TO=0, PF=0, PTS=0).save()
except:
# TODO: Log system.
# Restore player.
Player.objects.get(team=team, name=name).delete()
# 2016.05.24 Message framework.
messages.error(request, _('UNABLED_TO_CREATE_PLAYER'))
return redirect('player_index', team_id=team_id)
# Send invitation mail.
if email:
try:
# 2016.05.17 Version 1 email.
subject = "Welcome to the DataHoops - Sign Up and Join the Team"
from_email = settings.DEFAULT_FROM_EMAIL
to = email
html_content = "<h2>Welcome to the DataHoops!</h2><p>Hi "+smart_unicode(name)+",</p><p>You can use DataHoops to track your stats and improve your game!</p><p>To get started, <a href='http://www.datahoops.com/teams/myteams/"+str(team_id)+"/players/"+str(player.id)+"/invitation/'>click to log in/register</a> now.</p>"
msg = EmailMessage(subject, html_content, from_email, [to])
msg.content_subtype = "html"
msg.send()
except:
# TODO: Log system.
pass
# 2016.05.24 Message framework.
messages.success(request, _('PLAYER_CREATED'))
return HttpResponseRedirect('/teams/myteams/%s/players/' % team_id)
else:
# 2016.04.14 General team information.
# Query team instance.
team = Team.objects.get(id=team_id)
# Query team states instance.
stats = TeamState.objects.get(team=team)
# FG measurement.
if stats.two_points_attempt or stats.three_points_attempt:
FG = (stats.two_points_made + stats.three_points_made) / (stats.two_points_attempt + stats.three_points_attempt) * 100
else:
FG = 0.0
if stats.game:
# PPG measurement.
PPG = stats.PTS / stats.game
# AST/Game measurement.
AST = stats.AST / stats.game
# REB/Game measurement.
REB = stats.REB / stats.game
else:
PPG = AST = REB = 0.0
return render(request, 'players/create.html', locals())
def handle(self, *args, **options):
all_players = PlayerList().info()
for api_player in all_players:
info_msg = "'{} ({})'".format(
api_player['DISPLAY_FIRST_LAST'],
api_player['PERSON_ID']
)
# Get the player, or create him if doesn't exist
qs = Player.objects.filter(PERSON_ID=api_player['PERSON_ID'])
if qs.exists():
if options['skip']:
self.stdout.write(
self.style.SUCCESS("Skipping " + info_msg)
)
continue
player = qs[0]
self.stdout.write(self.style.SUCCESS("Updating " + info_msg))
else:
player = Player()
self.stdout.write(self.style.SUCCESS("Adding " + info_msg))
try:
name = api_player['DISPLAY_LAST_COMMA_FIRST']
last, first = name.replace(' ', '').split(',', 1)
except ValueError:
# Only one name
first = api_player['DISPLAY_LAST_COMMA_FIRST']
last = ''
player.first_name = first
player.last_name = last
player.PERSON_ID = api_player['PERSON_ID']
player.PLAYERCODE = api_player['PLAYERCODE']
# Add player photo only on creation
if not player.photo:
base_url = ('http://i.cdn.turner.com/nba/nba/.element/'
'img/2.0/sect/statscube/players/large/')
filename = api_player['PLAYERCODE'] + '.png'
photo_url = base_url + filename
# Try three times
session = requests.Session()
adapter = requests.adapters.HTTPAdapter(max_retries=3)
session.mount('http://', adapter)
response = session.get(photo_url)
if response:
image_content = ContentFile(response.content)
player.photo.save(filename, image_content)
player.save()
# Player current season
try:
player_stats = PlayerGeneralSplits(
api_player['PERSON_ID']
).overall()[0]
except IndexError:
self.stdout.write(self.style.ERROR("No stats for " + info_msg))
continue
season, __ = Season.objects.get_or_create(
abbr=player_stats['GROUP_VALUE'],
)
qs = PlayerSeason.objects.filter(
player=player, season=season,
)
if qs.exists():
player_season = qs[0]
else:
player_season = PlayerSeason()
# Team
if api_player['TEAM_ID'] and api_player['TEAM_CODE']:
team = Team.objects.get(TEAM_ID=api_player['TEAM_ID'])
else:
# Player played this season, but was cut/moved to D-League
team = None
player_season.team = team
player_season.player = player
player_season.season = season
player_season.ROSTERSTATUS = api_player['ROSTERSTATUS']
player_season.GAMES_PLAYED_FLAG = api_player['GAMES_PLAYED_FLAG']
player_season.pts = player_stats['PTS']
player_season.reb = player_stats['REB']
player_season.ast = player_stats['AST']
player_season.stl = player_stats['STL']
player_season.blk = player_stats['BLK']
player_season.fg_pct = player_stats['FG_PCT']
player_season.fg3_pct = player_stats['FG3_PCT']
player_season.ft_pct = player_stats['FT_PCT']
player_season.save()
self.stdout.write(self.style.SUCCESS("Successfully updated players"))
class TilePresenterTestCase(TestCase):
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 test_from_team(self):
presenter = TilePresenter.from_team(
x=0,
y=1,
team=self.team2,
game=self.game
)
self.assertEqual(presenter.x, 0)
self.assertEqual(presenter.y, 1)
self.assertEqual(presenter.name, 'A1')
self.assertTrue(presenter.is_empty)
self.assertFalse(presenter.is_hit)
def test_from_team_with_miss(self):
presenter = TilePresenter.from_team(
x=2,
y=3,
team=self.team2,
game=self.game
)
self.assertEqual(presenter.x, 2)
self.assertEqual(presenter.y, 3)
self.assertEqual(presenter.name, 'C3')
self.assertTrue(presenter.is_empty)
self.assertTrue(presenter.is_hit)
def test_from_team_with_ship(self):
presenter = TilePresenter.from_team(
x=3,
y=4,
team=self.team2,
game=self.game
)
self.assertEqual(presenter.x, 3)
self.assertEqual(presenter.y, 4)
self.assertEqual(presenter.name, 'D4')
self.assertFalse(presenter.is_empty)
self.assertFalse(presenter.is_hit)
def test_from_team_with_hit_ship(self):
presenter = TilePresenter.from_team(
x=3,
y=5,
team=self.team2,
game=self.game
)
self.assertEqual(presenter.x, 3)
self.assertEqual(presenter.y, 5)
self.assertEqual(presenter.name, 'D5')
self.assertFalse(presenter.is_empty)
self.assertTrue(presenter.is_hit)
def test_player_creation(self):
player = Player(name='Foo')
player.save()
self.assertEqual(player.name, 'Foo')
class HomeViewTestCase(TestCase):
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_logged_out(self):
url = reverse('home')
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
pq = PyQuery(resp.content)
self.assertIn('You\'re not logged in', pq('h3').text())
links = [e.attr('href') for e in pq('.container a').items()]
self.assertIn(reverse('login'), links)
self.assertIn(reverse('signup'), links)
def test_logged_in_with_matches(self):
self.client.login(
username=self.user1.username,
password='******'
)
url = reverse('home')
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
pq = PyQuery(resp.content)
# Assert links to 'Create New Game' plus ongoing games are shown
self.assertIn('Your Active Games', pq('h3').text())
links = [e.attr('href') for e in pq('.container a').items()]
self.assertIn(reverse('game', args=[self.game1.id]), links)
self.assertNotIn(reverse('game', args=[self.game2.id]), links)
self.assertIn(reverse('create_game'), links)
def test_logged_in_without_matches(self):
self.client.login(
username=self.user2.username,
password='******'
)
url = reverse('home')
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
pq = PyQuery(resp.content)
# Assert only link to 'Create New Game' is shown
self.assertEqual(len(pq('.container a')), 1)
links = [e.attr('href') for e in pq('.container a').items()]
self.assertIn(reverse('create_game'), links)
def setUp(self):
self.user = User.objects.create_user('user', '', 'password')
self.player = Player(user=self.user)
self.player.save()
class LoginViewTestCase(TestCase):
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 test_get(self):
url = reverse('login')
resp = self.client.get(url)
self.assertEqual(resp.status_code, 200)
pq = PyQuery(resp.content)
self.assertEqual(len(pq('input#username')), 1)
self.assertEqual(len(pq('input#password')), 1)
def test_post(self):
url = reverse('login')
resp = self.client.post(url, {
'username': '******',
'password': '******'
})
self.assertIn('_auth_user_id', self.client.session)
self.assertEqual(
int(self.client.session['_auth_user_id']),
self.active_user.id
)
self.assertRedirects(resp, reverse('home'))
def test_post_inactive_user(self):
url = reverse('login')
resp = self.client.post(url, {
'username': '******',
'password': '******'
})
self.assertEqual(resp.status_code, 200)
pq = PyQuery(resp.content)
self.assertIn(
'Your account is disabled',
pq('.alert-danger').text()
)
def test_post_bad_password(self):
url = reverse('login')
resp = self.client.post(url, {
'username': '******',
'password': '******'
})
self.assertEqual(resp.status_code, 200)
pq = PyQuery(resp.content)
self.assertIn(
'Your username and/or password is incorrect',
pq('.alert-danger').text()
)
