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)
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)' )
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() )